PHP Response::getMimeType方法代码示例

 /**
  * Checks if the response can be considered different according to the request
  * headers, and the caching response headers. If it was not modified, then the
  * render process is skipped. And the client will get a blank response with a
  * "304 Not Modified" header.
  *
  * - If Router::extensions() is enabled, the layout and template type are
  *   switched based on the parsed extension or Accept-Type header. For example,
  *   if `controller/action.xml` is requested, the view path becomes
  *   `app/View/Controller/xml/action.ctp`. Also if `controller/action` is
  *   requested with `Accept-Type: application/xml` in the headers the view
  *   path will become `app/View/Controller/xml/action.ctp`. Layout and template
  *   types will only switch to mime-types recognized by Cake\Network\Response.
  *   If you need to declare additional mime-types, you can do so using
  *   Cake\Network\Response::type() in your controller's beforeFilter() method.
  * - If a helper with the same name as the extension exists, it is added to
  *   the controller.
  * - If the extension is of a type that RequestHandler understands, it will
  *   set that Content-type in the response header.
  *
  * @param Event $event The Controller.beforeRender event.
  * @return bool false if the render process should be aborted
  */
 public function beforeRender(Event $event)
 {
     $isRecognized = !in_array($this->ext, ['html', 'htm']) && $this->response->getMimeType($this->ext);
     if (!empty($this->ext) && $isRecognized) {
         $this->renderAs($event->subject(), $this->ext);
     } elseif (empty($this->ext) || in_array($this->ext, ['html', 'htm'])) {
         $this->respondAs('html', ['charset' => Configure::read('App.encoding')]);
     }
     if ($this->_config['checkHttpCache'] && $this->response->checkNotModified($this->request)) {
         return false;
     }
 }

 /**
  * The startup method of the RequestHandler enables several automatic behaviors
  * related to the detection of certain properties of the HTTP request, including:
  *
  * - If Router::extensions() is enabled, the layout and template type are
  *   switched based on the parsed extension or Accept-Type header. For example, if `controller/action.xml`
  *   is requested, the view path becomes `app/View/Controller/xml/action.ctp`. Also if
  *   `controller/action` is requested with `Accept-Type: application/xml` in the headers
  *   the view path will become `app/View/Controller/xml/action.ctp`. Layout and template
  *   types will only switch to mime-types recognized by Cake\Network\Response. If you need to declare
  *   additional mime-types, you can do so using Cake\Network\Response::type() in your controller's beforeFilter()
  *   method.
  * - If a helper with the same name as the extension exists, it is added to the controller.
  * - If the extension is of a type that RequestHandler understands, it will set that
  *   Content-type in the response header.
  * - If the XML data is POSTed, the data is parsed into an XML object, which is assigned
  *   to the $data property of the controller, which can then be saved to a model object.
  *
  * @param Event $event The startup event that was fired.
  * @return void
  */
 public function startup(Event $event)
 {
     $controller = $event->subject();
     $request = $controller->request;
     if (isset($request->params['_ext'])) {
         $this->ext = $request->params['_ext'];
     }
     if (empty($this->ext) || in_array($this->ext, ['html', 'htm'])) {
         $this->_setExtension($request, $this->response);
     }
     if (empty($this->ext) && $request->is('ajax')) {
         $this->ext = 'ajax';
     }
     $request->params['isAjax'] = $this->request->is('ajax');
     $isRecognized = !in_array($this->ext, ['html', 'htm']) && $this->response->getMimeType($this->ext);
     if (!empty($this->ext) && $isRecognized) {
         $this->renderAs($controller, $this->ext);
     } elseif (empty($this->ext) || in_array($this->ext, ['html', 'htm'])) {
         $this->respondAs('html', ['charset' => Configure::read('App.encoding')]);
     }
     foreach ($this->_inputTypeMap as $type => $handler) {
         if ($this->requestedWith($type)) {
             $input = call_user_func_array([$request, 'input'], $handler);
             $request->data = (array) $input;
         }
     }
 }

 /**
  * Asserts content type
  *
  * @param string $type The content-type to check for.
  * @param string $message The failure message that will be appended to the generated message.
  * @return void
  */
 public function assertContentType($type, $message = '')
 {
     if (!$this->_response) {
         $this->fail('No response set, cannot assert content-type. ' . $message);
     }
     $alias = $this->_response->getMimeType($type);
     if ($alias !== false) {
         $type = $alias;
     }
     $result = $this->_response->type();
     $this->assertEquals($type, $result, $message);
 }

 /**
  * Returns an audio/video element
  *
  * ### Usage
  *
  * Using an audio file:
  *
  * ```
  * echo $this->Html->media('audio.mp3', ['fullBase' => true]);
  * ```
  *
  * Outputs:
  *
  * `<video src="http://www.somehost.com/files/audio.mp3">Fallback text</video>`
  *
  * Using a video file:
  *
  * ```
  * echo $this->Html->media('video.mp4', ['text' => 'Fallback text']);
  * ```
  *
  * Outputs:
  *
  * `<video src="/files/video.mp4">Fallback text</video>`
  *
  * Using multiple video files:
  *
  * ```
  * echo $this->Html->media(
  *      ['video.mp4', ['src' => 'video.ogv', 'type' => "video/ogg; codecs='theora, vorbis'"]],
  *      ['tag' => 'video', 'autoplay']
  * );
  * ```
  *
  * Outputs:
  *
  * ```
  * <video autoplay="autoplay">
  *      <source src="/files/video.mp4" type="video/mp4"/>
  *      <source src="/files/video.ogv" type="video/ogv; codecs='theora, vorbis'"/>
  * </video>
  * ```
  *
  * ### Options
  *
  * - `tag` Type of media element to generate, either "audio" or "video".
  *  If tag is not provided it's guessed based on file's mime type.
  * - `text` Text to include inside the audio/video tag
  * - `pathPrefix` Path prefix to use for relative URLs, defaults to 'files/'
  * - `fullBase` If provided the src attribute will get a full address including domain name
  *
  * @param string|array $path Path to the video file, relative to the webroot/{$options['pathPrefix']} directory.
  *  Or an array where each item itself can be a path string or an associate array containing keys `src` and `type`
  * @param array $options Array of HTML attributes, and special options above.
  * @return string Generated media element
  */
 public function media($path, array $options = [])
 {
     $options += ['tag' => null, 'pathPrefix' => 'files/', 'text' => ''];
     if (!empty($options['tag'])) {
         $tag = $options['tag'];
     } else {
         $tag = null;
     }
     if (is_array($path)) {
         $sourceTags = '';
         foreach ($path as &$source) {
             if (is_string($source)) {
                 $source = ['src' => $source];
             }
             if (!isset($source['type'])) {
                 $ext = pathinfo($source['src'], PATHINFO_EXTENSION);
                 $source['type'] = $this->response->getMimeType($ext);
             }
             $source['src'] = $this->Url->assetUrl($source['src'], $options);
             $sourceTags .= $this->formatTemplate('tagselfclosing', ['tag' => 'source', 'attrs' => $this->templater()->formatAttributes($source)]);
         }
         unset($source);
         $options['text'] = $sourceTags . $options['text'];
         unset($options['fullBase']);
     } else {
         if (empty($path) && !empty($options['src'])) {
             $path = $options['src'];
         }
         $options['src'] = $this->Url->assetUrl($path, $options);
     }
     if ($tag === null) {
         if (is_array($path)) {
             $mimeType = $path[0]['type'];
         } else {
             $mimeType = $this->response->getMimeType(pathinfo($path, PATHINFO_EXTENSION));
         }
         if (preg_match('#^video/#', $mimeType)) {
             $tag = 'video';
         } else {
             $tag = 'audio';
         }
     }
     if (isset($options['poster'])) {
         $options['poster'] = $this->Url->assetUrl($options['poster'], ['pathPrefix' => Configure::read('App.imageBaseUrl')] + $options);
//.........这里部分代码省略.........

 /**
  * The startup method of the RequestHandler enables several automatic behaviors
  * related to the detection of certain properties of the HTTP request, including:
  *
  * - If Router::extensions() is enabled, the layout and template type are
  *   switched based on the parsed extension or Accept-Type header. For example, if `controller/action.xml`
  *   is requested, the view path becomes `app/View/Controller/xml/action.ctp`. Also if
  *   `controller/action` is requested with `Accept-Type: application/xml` in the headers
  *   the view path will become `app/View/Controller/xml/action.ctp`. Layout and template
  *   types will only switch to mime-types recognized by Cake\Network\Response. If you need to declare
  *   additional mime-types, you can do so using Cake\Network\Response::type() in your controllers beforeFilter()
  *   method.
  * - If a helper with the same name as the extension exists, it is added to the controller.
  * - If the extension is of a type that RequestHandler understands, it will set that
  *   Content-type in the response header.
  * - If the XML data is POSTed, the data is parsed into an XML object, which is assigned
  *   to the $data property of the controller, which can then be saved to a model object.
  *
  * @param Event $event The startup event that was fired.
  * @return void
  */
 public function startup(Event $event)
 {
     $controller = $event->subject();
     $controller->request->params['isAjax'] = $this->request->is('ajax');
     $isRecognized = !in_array($this->ext, array('html', 'htm')) && $this->response->getMimeType($this->ext);
     if (!empty($this->ext) && $isRecognized) {
         $this->renderAs($controller, $this->ext);
     } elseif (empty($this->ext) || in_array($this->ext, array('html', 'htm'))) {
         $this->respondAs('html', array('charset' => Configure::read('App.encoding')));
     }
     foreach ($this->_inputTypeMap as $type => $handler) {
         if ($this->requestedWith($type)) {
             $input = call_user_func_array(array($controller->request, 'input'), $handler);
             $controller->request->data = $input;
         }
     }
 }

 /**
  * Tests the request object constructor
  *
  * @return void
  */
 public function testConstruct()
 {
     $response = new Response();
     $this->assertNull($response->body());
     $this->assertEquals('UTF-8', $response->charset());
     $this->assertEquals('text/html', $response->type());
     $this->assertEquals(200, $response->statusCode());
     $options = ['body' => 'This is the body', 'charset' => 'my-custom-charset', 'type' => 'mp3', 'status' => '203'];
     $response = new Response($options);
     $this->assertEquals('This is the body', $response->body());
     $this->assertEquals('my-custom-charset', $response->charset());
     $this->assertEquals('audio/mpeg', $response->type());
     $this->assertEquals(203, $response->statusCode());
     $options = ['body' => 'This is the body', 'charset' => 'my-custom-charset', 'type' => 'mp3', 'status' => '422', 'statusCodes' => [422 => 'Unprocessable Entity']];
     $response = new Response($options);
     $this->assertEquals($options['body'], $response->body());
     $this->assertEquals($options['charset'], $response->charset());
     $this->assertEquals($response->getMimeType($options['type']), $response->type());
     $this->assertEquals($options['status'], $response->statusCode());
 }

 /**
  * Maps a content type alias back to its mime-type(s)
  *
  * @param string|array $alias String alias to convert back into a content type. Or an array of aliases to map.
  * @return string Null on an undefined alias. String value of the mapped alias type. If an
  *   alias maps to more than one content type, the first one will be returned.
  */
 public function mapAlias($alias)
 {
     if (is_array($alias)) {
         return array_map(array($this, 'mapAlias'), $alias);
     }
     $type = $this->response->getMimeType($alias);
     if ($type) {
         if (is_array($type)) {
             return $type[0];
         }
         return $type;
     }
     return null;
 }