(responseObserver: Observer<Response>) => {
                const headers = req.headers.toJSON();
                Object.keys(headers).map(function(key) {
                    if (headers[key].length > 1) {
                        throw `Header ${key} contains more than one value`;
                    }
                    headers[key] = headers[key][0];
                });

                let body;

                // 1 stands for ContentType.JSON. Angular doesn't export ContentType
                if (req.detectContentTypeFromBody() === 1) {
                    body = req.json();
                } else {
                    body = this.getBodyParams(req.getBody());
                }

                const requestMethod = this.detectRequestMethod(req);

                /**
                 * Request contains either encoded either decoded URL depended on the way
                 * parameters are passed to Http component. Even though XMLHttpRequest automatically
                 * converts unencoded URL, NativeHTTP requires it to be always encoded.
                 */
                const url = encodeURI(decodeURI(req.url)).replace('%252F', '%2F');

                nativeHttp.setDataSerializer(
                    this.detectDataSerializerType(req),
                );

                nativeHttp[requestMethod](url, body, headers)
                    .then((response: HTTPResponse) => {
                        this.fireResponse(
                            responseObserver,
                            new ResponseOptions({
                                body: response.data,
                                status: response.status,
                                headers: new Headers(response.headers),
                            }),
                            baseResponseOptions,
                        );
                    })
                    .catch((error: HTTPError) => {
                        this.fireResponse(
                            responseObserver,
                            new ResponseOptions({
                                body: error.error,
                                status: error.status || 599, // https://httpstatuses.com/599
                                headers: new Headers(error.headers),
                            }),
                            baseResponseOptions,
                        );
                    });
            },

        return new Observable((observer: Observer<HttpEvent<any>>) => {
            const headers = new Map<string, string>();
            req.headers.keys().map(function(key) {
                headers[key] = req.headers.get(key);
            });

            let body;

            if (typeof req.body === 'string') {
                body = this.getBodyParams(req.body);
            } else if (Array.isArray(req.body)) {
                body = req.body;
            } else {
                body = { ...req.body };
            }

            const requestMethod = req.method.toLowerCase() as HTTPRequestMethod;

            /**
             * Request contains either encoded either decoded URL depended on the way
             * parameters are passed to Http component. Even though XMLHttpRequest automatically
             * converts not encoded URL, NativeHTTP requires it to be always encoded.
             */
            const url = encodeURI(decodeURI(req.urlWithParams)).replace(
                '%252F',
                '%2F',
            );

            const fireResponse = (response: {
                body: string;
                status: number;
                headers: any;
            }) => {
                // ok determines whether the response will be transmitted on the event or
                // error channel. Unsuccessful status codes (not 2xx) will always be errors,
                // but a successful status code can still result in an error if the user
                // asked for JSON data and the body cannot be parsed as such.
                let ok = response.status >= 200 && response.status < 300;

                let body: any = response.body;

                // Check whether the body needs to be parsed as JSON (in many cases the browser
                // will have done that already).
                if (req.responseType === 'json' && typeof body === 'string') {
                    // Save the original body, before attempting XSSI prefix stripping.
                    const originalBody = body;
                    body = body.replace(XSSI_PREFIX, '');
                    try {
                        // Attempt the parse. If it fails, a parse error should be delivered to the user.
                        body = body !== '' ? JSON.parse(body) : null;
                    } catch (error) {
                        // Since the JSON.parse failed, it's reasonable to assume this might not have been a
                        // JSON response. Restore the original body (including any XSSI prefix) to deliver
                        // a better error response.
                        body = originalBody;

                        // If this was an error request to begin with, leave it as a string, it probably
                        // just isn't JSON. Otherwise, deliver the parsing error to the user.
                        if (ok) {
                            // Even though the response status was 2xx, this is still an error.
                            ok = false;
                            // The parse error contains the text of the body that failed to parse.
                            body = { error, text: body } as HttpJsonParseError;
                        }
                    }
                }

                if (ok) {
                    // A successful response is delivered on the event stream.
                    observer.next(
                        new HttpResponse({
                            body,
                            headers: new HttpHeaders(response.headers),
                            status: response.status,
                        }),
                    );
                    // The full body has been received and delivered, no further events
                    // are possible. This request is complete.
                    observer.complete();
                } else {
                    // An unsuccessful request is delivered on the error channel.
                    observer.error(
                        new HttpErrorResponse({
                            // The error in this case is the response body (error from the server).
                            error: body,
                            headers: new HttpHeaders(response.headers),
                            status: response.status,
                        }),
                    );
                }
            };

            this.nativeHttp.setDataSerializer(
                this.detectDataSerializerType(req),
            );

            this.nativeHttp[requestMethod](url, body, { ...headers })
                .then((response: HTTPResponse) => {
                    fireResponse({
                        body: response.data,
//.........这里部分代码省略.........

 return new Promise((resolve, reject) => {
   if ("cordova" in window) {
     this.nativeHttp.get(url, {}, {}).then(success => {
       if (success.status == 200) {
         resolve(JSON.parse(success.data));
       }else {
         reject(success.status);
       }
     }).catch(err => {
       reject(err);
     });
   }else {
     this.http.get(url)
       .timeout(2000)
       .map(res => res.json())
       .subscribe(data => {
         resolve(data);
       }, err => {
         if (err instanceof TimeoutError) {
           err = 408;
         }
         reject(err);
       });
   }
 });

 // 百度TTS 合成token
 getTTSAccessToken()
 {
   let url = "https://openapi.baidu.com/oauth/2.0/token";
   let params = {
     "grant_type": "client_credentials",
     "client_id": "TPnGgO8zxIayL9iTTctlxqny",
     "client_secret": "820591dad6912546574487991d6bcb7d"
   };
   if(this.platform.is("cordova"))
   {
     return Observable.fromPromise(this.nativeHttp.get(url, params, {})).map((res:any) =>{
       return JSON.parse(res.data);
     }).catch(this.handleError);
   }
   else
   {
     url = url.replace("https:/", "");
     let searchParams = new URLSearchParams();
     for(let key in params)
     {
       searchParams.set(key, params[key]);
     }
     let reqOpts = new RequestOptions({"search": searchParams, "headers": new Headers()});
     return this.http.get(url, reqOpts).map(res=>{
       return res.json();
     }).catch(this.handleError);
   }
 }

this.platform.ready().then(() => this.http.get(API_BASE, {}, {}))