http.dart 7.73 KB
Newer Older
1 2 3 4 5 6 7 8
// Copyright (c) 2013, the Dart project authors.  Please see the AUTHORS file
// for details. All rights reserved. Use of this source code is governed by a
// BSD-style license that can be found in the LICENSE file.

import 'dart:async';
import 'dart:convert';
import 'dart:typed_data';

Adam Barth's avatar
Adam Barth committed
9 10
import 'package:mojo/core.dart' as mojo;

11 12 13 14 15 16
import 'mojo_client.dart';
import 'response.dart';

/// Sends an HTTP HEAD request with the given headers to the given URL, which
/// can be a [Uri] or a [String].
///
17
/// This automatically initializes a new [MojoClient] and closes that client once
18
/// the request is complete. If you're planning on making multiple requests to
19 20 21 22
/// the same server, you should use a single [MojoClient] for all of those requests.
Future<Response> head(dynamic url) {
  return _withClient/*<Response>*/((MojoClient client) => client.head(url));
}
23 24 25 26

/// Sends an HTTP GET request with the given headers to the given URL, which can
/// be a [Uri] or a [String].
///
27
/// This automatically initializes a new [MojoClient] and closes that client once
28
/// the request is complete. If you're planning on making multiple requests to
29 30 31 32
/// the same server, you should use a single [MojoClient] for all of those requests.
Future<Response> get(dynamic url, { Map<String, String> headers }) {
  return _withClient/*<Response>*/((MojoClient client) => client.get(url, headers: headers));
}
33 34 35 36

/// Sends an HTTP POST request with the given headers and body to the given URL,
/// which can be a [Uri] or a [String].
///
37 38 39 40 41 42 43 44 45 46 47 48 49 50 51 52 53 54 55 56 57 58
/// [body] sets the body of the request. It can be a [String], a [List<int>] or
/// a [Map<String, String>]. If it's a String, it's encoded using [encoding] and
/// used as the body of the request. The content-type of the request will
/// default to "text/plain".
///
/// If [body] is a List, it's used as a list of bytes for the body of the
/// request.
///
/// If [body] is a Map, it's encoded as form fields using [encoding]. The
/// content-type of the request will be set to
/// `"application/x-www-form-urlencoded"`; this cannot be overridden.
///
/// [encoding] defaults to [UTF8].
///
/// This automatically initializes a new [MojoClient] and closes that client once
/// the request is complete. If you're planning on making multiple requests to
/// the same server, you should use a single [MojoClient] for all of those requests.
Future<Response> post(dynamic url, { Map<String, String> headers, dynamic body, Encoding encoding: UTF8 }) {
  return _withClient/*<Response>*/((MojoClient client) {
    return client.post(url, headers: headers, body: body, encoding: encoding);
  });
}
59 60 61 62 63 64 65 66

/// Sends an HTTP PUT request with the given headers and body to the given URL,
/// which can be a [Uri] or a [String].
///
/// [body] sets the body of the request. It can be a [String], a [List<int>] or
/// a [Map<String, String>]. If it's a String, it's encoded using [encoding] and
/// used as the body of the request. The content-type of the request will
/// default to "text/plain".
67 68 69 70 71 72 73 74 75 76 77 78 79 80 81 82 83 84
///
/// If [body] is a List, it's used as a list of bytes for the body of the
/// request.
///
/// If [body] is a Map, it's encoded as form fields using [encoding]. The
/// content-type of the request will be set to
/// `"application/x-www-form-urlencoded"`; this cannot be overridden.
///
/// [encoding] defaults to [UTF8].
///
/// This automatically initializes a new [MojoClient] and closes that client once
/// the request is complete. If you're planning on making multiple requests to
/// the same server, you should use a single [MojoClient] for all of those requests.
Future<Response> put(dynamic url, { Map<String, String> headers, dynamic body, Encoding encoding: UTF8 }) {
  return _withClient/*<Response>*/((MojoClient client) {
    return client.put(url, headers: headers, body: body, encoding: encoding);
  });
}
85 86 87 88 89 90 91 92 93 94 95 96 97 98 99 100 101 102

/// Sends an HTTP PATCH request with the given headers and body to the given
/// URL, which can be a [Uri] or a [String].
///
/// [body] sets the body of the request. It can be a [String], a [List<int>] or
/// a [Map<String, String>]. If it's a String, it's encoded using [encoding] and
/// used as the body of the request. The content-type of the request will
/// default to "text/plain".
///
/// If [body] is a List, it's used as a list of bytes for the body of the
/// request.
///
/// If [body] is a Map, it's encoded as form fields using [encoding]. The
/// content-type of the request will be set to
/// `"application/x-www-form-urlencoded"`; this cannot be overridden.
///
/// [encoding] defaults to [UTF8].
///
103 104 105 106 107 108 109 110
/// This automatically initializes a new [MojoClient] and closes that client once
/// the request is complete. If you're planning on making multiple requests to
/// the same server, you should use a single [MojoClient] for all of those requests.
Future<Response> patch(dynamic url, { Map<String, String> headers, dynamic body, Encoding encoding: UTF8 }) {
  return _withClient/*<Response>*/((MojoClient client) {
     return client.patch(url, headers: headers, body: body, encoding: encoding);
  });
}
111 112 113 114

/// Sends an HTTP DELETE request with the given headers to the given URL, which
/// can be a [Uri] or a [String].
///
115
/// This automatically initializes a new [MojoClient] and closes that client once
116
/// the request is complete. If you're planning on making multiple requests to
117 118 119 120
/// the same server, you should use a single [MojoClient] for all of those requests.
Future<Response> delete(dynamic url, { Map<String, String> headers }) {
  return _withClient/*<Response>*/((MojoClient client) => client.delete(url, headers: headers));
}
121 122 123 124 125 126 127 128

/// Sends an HTTP GET request with the given headers to the given URL, which can
/// be a [Uri] or a [String], and returns a Future that completes to the body of
/// the response as a [String].
///
/// The Future will emit a [ClientException] if the response doesn't have a
/// success status code.
///
129
/// This automatically initializes a new [MojoClient] and closes that client once
130
/// the request is complete. If you're planning on making multiple requests to
131 132 133 134
/// the same server, you should use a single [MojoClient] for all of those requests.
Future<String> read(dynamic url, { Map<String, String> headers }) {
  return _withClient/*<String>*/((MojoClient client) => client.read(url, headers: headers));
}
135 136 137 138 139 140 141 142

/// Sends an HTTP GET request with the given headers to the given URL, which can
/// be a [Uri] or a [String], and returns a Future that completes to the body of
/// the response as a list of bytes.
///
/// The Future will emit a [ClientException] if the response doesn't have a
/// success status code.
///
143
/// This automatically initializes a new [MojoClient] and closes that client once
144
/// the request is complete. If you're planning on making multiple requests to
145 146 147 148
/// the same server, you should use a single [MojoClient] for all of those requests.
Future<Uint8List> readBytes(dynamic url, { Map<String, String> headers }) {
  return _withClient/*<Uint8List>*/((MojoClient client) => client.readBytes(url, headers: headers));
}
149

Adam Barth's avatar
Adam Barth committed
150 151 152 153 154 155 156 157 158 159 160 161 162 163
/// Sends an HTTP GET request with the given headers to the given URL, which can
/// be a [Uri] or a [String], and returns a Future that completes to a data pipe
/// containing the response bytes.
///
/// The Future will emit a [ClientException] if the response doesn't have a
/// success status code.
///
/// This automatically initializes a new [MojoClient] and closes that client once
/// the request is complete. If you're planning on making multiple requests to
/// the same server, you should use a single [MojoClient] for all of those requests.
Future<mojo.MojoDataPipeConsumer> readDataPipe(dynamic url, { Map<String, String> headers }) {
  return _withClient/*<mojo.MojoDataPipeConsumer>*/((MojoClient client) => client.readDataPipe(url, headers: headers));
}

164
Future<dynamic/*=T*/> _withClient/*<T>*/(Future<dynamic/*=T*/> fn(MojoClient client)) {
165
  return fn(new MojoClient());
166
}