PHP Util::guessMimeType方法代码示例

 /**
  * {@inheritdoc}
  */
 public function update($path, $contents, Config $config)
 {
     $location = $this->applyPathPrefix($path);
     $mimetype = Util::guessMimeType($path, $contents);
     if (($size = file_put_contents($location, $contents)) === false) {
         return false;
     }
     return compact('path', 'size', 'contents', 'mimetype');
 }

 /**
  * Update a file
  *
  * @param   string       $path
  * @param   string       $contents
  * @param   mixed        $config   Config object or visibility setting
  * @return  array|bool
  */
 public function update($path, $contents, Config $config)
 {
     list($ret, $err) = Qiniu_RS_Put($this->getClient(), $this->bucket, $path, $contents, null);
     if ($err !== null) {
         return false;
     }
     $mimetype = Util::guessMimeType($path, $contents);
     return compact('mimetype', 'path');
 }

 /**
  * Write a file
  *
  * @param   string  $path
  * @param   string  $contents
  * @param   mixed   $config
  * @return  array   file metadata
  */
 public function write($path, $contents, $config = null)
 {
     $config = Util::ensureConfig($config);
     $options = $this->getOptions($path, array('Body' => $contents, 'ContentType' => Util::guessMimeType($path, $contents), 'ContentLength' => Util::contentSize($contents)), $config);
     $result = $this->client->putObject($options);
     if ($result === false) {
         return false;
     }
     return $this->normalizeObject($options);
 }

 /**
  * Write a new file.
  *
  * @param string $path
  * @param string $contents
  * @param Config $config Config object
  * @return array|false false on failure file meta data on success
  */
 public function write($path, $contents, Config $config = null)
 {
     $tmpFile = tempnam(sys_get_temp_dir(), 'arconnect-static');
     file_put_contents($tmpFile, $contents);
     $file = new \CURLFile($tmpFile, Util::guessMimeType($path, $tmpFile), basename($tmpFile));
     $data = ['slug' => $path, 'file' => $file];
     $ch = curl_init();
     curl_setopt($ch, CURLOPT_URL, $this->apiUrl . '/' . $this->application);
     curl_setopt($ch, CURLOPT_POST, 1);
     curl_setopt($ch, CURLOPT_POSTFIELDS, $data);
     curl_setopt($ch, CURLOPT_RETURNTRANSFER, 1);
     curl_exec($ch);
     $fileInfo = curl_getinfo($ch);
     curl_close($ch);
     unlink($tmpFile);
     if ($fileInfo['http_code'] >= 200 && $fileInfo['http_code'] < 400) {
         $response = ['contents' => $contents, 'type' => $fileInfo['content_type'], 'size' => $fileInfo['size_download'], 'path' => $path];
         return $response;
     }
     return false;
 }

 /**
  * Write a new file.
  *
  * @param string $path
  * @param string $contents
  * @param Config $config Config object
  * @return array|false false on failure file meta data on success
  */
 public function write($path, $contents, Config $config)
 {
     $object = $this->applyPathPrefix($path);
     $options = $this->getOptionsFromConfig($config);
     if (!isset($options[OssClient::OSS_LENGTH])) {
         $options[OssClient::OSS_LENGTH] = Util::contentSize($contents);
     }
     if (!isset($options[OssClient::OSS_CONTENT_TYPE])) {
         $options[OssClient::OSS_CONTENT_TYPE] = Util::guessMimeType($path, $contents);
     }
     try {
         $this->client->putObject($this->bucket, $object, $contents, $options);
     } catch (OssException $e) {
         return false;
     }
     $type = 'file';
     $result = compact('type', 'path', 'contents');
     $result['mimetype'] = $options[OssClient::OSS_CONTENT_TYPE];
     $result['size'] = $options[OssClient::OSS_LENGTH];
     return $result;
 }

 /**
  * {@inheritdoc}
  */
 public function getMetadata($path)
 {
     $info = $this->getPathInfo($path);
     if (!$this->has($path)) {
         throw new \League\Flysystem\FileNotFoundException("File not found at path: {$info['path']}");
     }
     $metadata = json_decode($this->redis->hget($this->applyPathPrefix($info['dirname']), $info['basename']), TRUE);
     if ($metadata['type'] === 'file') {
         $metadata['contents'] = base64_decode($metadata['contents']);
         $metadata += ['size' => Util::contentSize($metadata['contents']), 'mimetype' => Util::guessMimeType($metadata['path'], $metadata['contents'])];
         unset($metadata['contents']);
     }
     return $metadata;
 }

 /**
  * Get the mime-type from a given path or content
  *
  * @param string $path
  * @param string|resource $content
  * @return string
  */
 private function getMimeType($path, $content)
 {
     if (is_resource($content)) {
         $meta = stream_get_meta_data($content);
         $ext = pathinfo($meta['uri'], PATHINFO_EXTENSION);
         $map = MimeType::getExtensionToMimeTypeMap();
         if (isset($map[$ext])) {
             return $map[$ext];
         } else {
             return '';
         }
     } else {
         return Util::guessMimeType($path, $content);
     }
 }

 /**
  * @inheritdoc
  */
 public function write($path, $contents, Config $config)
 {
     $stream = fopen('php://temp', 'w+b');
     fwrite($stream, $contents);
     rewind($stream);
     $result = $this->writeStream($path, $stream, $config);
     fclose($stream);
     if ($result === false) {
         return false;
     }
     $result['contents'] = $contents;
     $result['mimetype'] = Util::guessMimeType($path, $contents);
     return $result;
 }

 /**
  * @inheritdoc
  */
 public function write($path, $contents, Config $config)
 {
     $result = $this->getClient()->putObject($this->bucket, $path, $contents);
     if ($result !== null) {
         return false;
     }
     $mimetype = Util::guessMimeType($path, $contents);
     return compact('mimetype', 'path');
 }

 /**
  * Write a file
  *
  * @param   string  $path
  * @param   string  $contents
  * @param   mixed   $config
  * @return  array   file metadata
  */
 public function write($path, $contents, $config = null)
 {
     $mimeType = Util::guessMimeType($path, $contents);
     if (isset($config)) {
         if (isset($config["mimeType"])) {
             $mimeType = $config["mimeType"];
         }
     }
     $config = Util::ensureConfig($config);
     $options = $this->getOptions($path, array('ContentType' => $mimeType, 'ContentLength' => Util::contentSize($contents)), $config);
     $dirname = dirname($path);
     $filename = basename($path);
     if ($this->has($path)) {
         $isUpdate = true;
         $file = $this->service->files->get($path);
     } else {
         $file = new Google_Service_Drive_DriveFile();
         $file->setTitle($filename);
         $file->setMimeType($mimeType);
         if ($dirname != ".") {
             $parent = new Google_Service_Drive_ParentReference();
             $parent->setId($dirname);
             $file->setParents(array($parent));
         }
     }
     if (isset($isUpdate)) {
         $result = $this->service->files->update($file['id'], $file, array('data' => $contents, 'mimeType' => $mimeType, 'uploadType' => "multipart"));
     } else {
         $result = $this->service->files->insert($file, array('data' => $contents, 'mimeType' => $mimeType, 'uploadType' => "multipart"));
     }
     if ($result === false) {
         return false;
     }
     $result['mimeType'] = $mimeType;
     $result['title'] = $filename;
     $result['id'] = $result->getId();
     return $this->normalizeObject($result);
 }

 /**
  * Write a file
  *
  * @param   string $path
  * @param   string $contents
  * @param   mixed  $config
  *
  * @return  array   file metadata
  */
 public function write($path, $contents, $config = null)
 {
     $options = $this->getOptions($path, array('Body' => $contents, 'ContentType' => Util::guessMimeType($path, $contents), 'ContentLength' => Util::contentSize($contents)), $config = Util::ensureConfig($config));
     return $this->writeObject($options);
 }

 /**
  * @inheritdoc
  */
 public function write($path, $contents, Config $config)
 {
     $stream = fopen('php://temp', 'w+b');
     fwrite($stream, $contents);
     rewind($stream);
     $result = $this->writeStream($path, $stream, $config);
     is_resource($stream) && fclose($stream);
     // TODO 去掉is_resource判断
     $result['contents'] = $contents;
     $result['mimetype'] = Util::guessMimeType($path, $contents);
     return $result;
 }

 public function getMimetype($path)
 {
     $mimetype = Util::guessMimeType($path, $this->read($path)['contents']);
     return ['mimetype' => $mimetype, 'path' => $path];
 }

 /**
  * Get the mimetype of a file.
  *
  * @param string $path
  *
  * @return array|false
  */
 public function getMimetype($path)
 {
     $stream = tmpfile();
     fwrite($stream, $this->client->get($path));
     rewind($stream);
     return ['mimetype' => Util::guessMimeType(stream_get_meta_data($stream)['uri'], stream_get_contents($stream))];
 }

 /**
  * {@inheritdoc}
  */
 public function update($path, $contents, Config $config)
 {
     if (!$this->hasFile($path)) {
         return false;
     }
     $this->storage[$path]['contents'] = $contents;
     $this->storage[$path]['timestamp'] = time();
     $this->storage[$path]['size'] = Util::contentSize($contents);
     $this->storage[$path]['mimetype'] = Util::guessMimeType($path, $contents);
     if ($visibility = $config->get('visibility')) {
         $this->setVisibility($path, $visibility);
     }
     return $this->getMetadata($path);
 }