Returns the channel type.

@return string Either 'text' or 'voice'.
4418
public function getChannelType()
    {
        switch ($this->type) {
            case self::TYPE_TEXT:
            case self::TYPE_VOICE:
                return $this->type;
                break;
            default:
                return self::TYPE_TEXT;
                break;
        }
    }
401970
public function get_type()
	{
		if (isset($this->file->headers['content-type']))
		{
			if (!isset($this->file->headers['content-encoding'])
				&& ($this->file->headers['content-type'] === 'text/plain'
					|| $this->file->headers['content-type'] === 'text/plain; charset=ISO-8859-1'
					|| $this->file->headers['content-type'] === 'text/plain; charset=iso-8859-1'
					|| $this->file->headers['content-type'] === 'text/plain; charset=UTF-8'))
			{
				return $this->text_or_binary();
			}

			if (($pos = strpos($this->file->headers['content-type'], ';')) !== false)
			{
				$official = substr($this->file->headers['content-type'], 0, $pos);
			}
			else
			{
				$official = $this->file->headers['content-type'];
			}
			$official = trim(strtolower($official));

			if ($official === 'unknown/unknown'
				|| $official === 'application/unknown')
			{
				return $this->unknown();
			}
			elseif (substr($official, -4) === '+xml'
				|| $official === 'text/xml'
				|| $official === 'application/xml')
			{
				return $official;
			}
			elseif (substr($official, 0, 6) === 'image/')
			{
				if ($return = $this->image())
				{
					return $return;
				}
				else
				{
					return $official;
				}
			}
			elseif ($official === 'text/html')
			{
				return $this->feed_or_html();
			}
			else
			{
				return $official;
			}
		}
		else
		{
			return $this->unknown();
		}
	}
407621
public function getMimeType(): ?string
	{
		$info = finfo_open(FILEINFO_MIME_TYPE);

		$mime = finfo_file($info, $this->getPathname());

		finfo_close($info);

		return $mime ?: null;
	}
1053700
protected function getSpacerType()
  {
    $type = "";

    if(!$this->currObj instanceof Channel || !$this->currObj->isSpacer())
    {
      return "none";
    }

    switch($this->currObj->spacerGetType())
    {
      case (string) TeamSpeak3::SPACER_SOLIDLINE:
        $type .= "solidline";
        break;

      case (string) TeamSpeak3::SPACER_DASHLINE:
        $type .= "dashline";
        break;

      case (string) TeamSpeak3::SPACER_DASHDOTLINE:
        $type .= "dashdotline";
        break;

      case (string) TeamSpeak3::SPACER_DASHDOTDOTLINE:
        $type .= "dashdotdotline";
        break;

      case (string) TeamSpeak3::SPACER_DOTLINE:
        $type .= "dotline";
        break;

      default:
        $type .= "custom";
    }

    if($type == "custom")
    {
      switch($this->currObj->spacerGetAlign())
      {
        case TeamSpeak3::SPACER_ALIGN_REPEAT:
          $type .= "repeat";
          break;

        case TeamSpeak3::SPACER_ALIGN_CENTER:
          $type .= "center";
          break;

        case TeamSpeak3::SPACER_ALIGN_RIGHT:
          $type .= "right";
          break;

        default:
          $type .= "left";
      }
    }

    return $type;
  }
58611
public String getType() {
        Object type = getHeader(JmsMessageHeaders.TYPE);

        if (type != null) {
            return type.toString();
        }

        return null;
    }
1192162
public static function get_device_type() {
        $instance = self::instance();
        if ($instance->devicetype === null) {
            return $instance->guess_device_type();
        }
        return $instance->devicetype;
    }
496771
protected function getContenType(): string
	{
		return $this->contentType ?? ($this->fileSystem->info($this->filePath)->getMimeType() ?? 'application/octet-stream');
	}
1140812
public function getDeviceType()
    {
        $device = $this->session->get('device');

        if (empty($device)) {

            $detector = $this->getLibrary();

            if ($detector->isMobile()) {
                $device = 'mobile';
            } else if ($detector->isTablet()) {
                $device = 'tablet';
            } else {
                $device = 'desktop';
            }

            $this->session->set('device', $device);
        }

        return $device;
    }
364028
public function getLanguage()
    {
        if (!is_array($this->languages)) {
            LanguageDetector::detect($this, $this->getAcceptLanguage());
        }

        return strtolower(substr(reset($this->languages), 0, 2));
    }
1106162
function _get_interactive_channel()
    {
        switch (true) {
            case $this->in_subsystem:
                return self::CHANNEL_SUBSYSTEM;
            case $this->in_request_pty_exec:
                return self::CHANNEL_EXEC;
            default:
                return self::CHANNEL_SHELL;
        }
    }
1348621
public function getEncType()
    {
        if ($this->encType) {
            return $this->encType;
        }

        if ($fields = $this->fields->dataFields()) {
            foreach ($fields as $field) {
                if ($field instanceof FileField) {
                    return self::ENC_TYPE_MULTIPART;
                }
            }
        }

        return self::ENC_TYPE_URLENCODED;
    }
1157274
public function broadcastType()
    {
        return method_exists($this->notification, 'broadcastType')
                    ? $this->notification->broadcastType()
                    : get_class($this->notification);
    }
10729
public String getChannelMode()
	{
		String str = null;

		if ((channelMode >= 0) && (channelMode < channelLabels.length))
		{
			str = channelLabels[channelMode];
		}

		return str;
	}
243331
public function getContentType() {
		if (!isset($this->contentType)) {
			$numOfMatches = preg_match('/^([^;]*)/', $this->getHeader('Content-Type'), $matches);
			if ($numOfMatches) {
				$this->contentType = trim($matches[1]);
			} else {
				$this->contentType = '';
			}
		}
		return $this->contentType;
	}
1198208
public function getAlertMessageType()
    {
        // Obtain Base Alert Class:
        
        $classes = $this->styles('alert');
        
        // Determine Message Type:
        
        switch ($this->owner->MessageType) {
            case ValidationResult::TYPE_GOOD:
                $classes[] = $this->style('alert.success');
                break;
            case ValidationResult::TYPE_INFO:
                $classes[] = $this->style('alert.info');
                break;
            case ValidationResult::TYPE_ERROR:
                $classes[] = $this->style('alert.danger');
                break;
            default:
                $classes[] = $this->style('alert.warning');
        }
        
        // Answer Classes:
        
        return ViewTools::singleton()->array2att($classes);
    }
1055455
public function getAbstractType(): string
    {
        foreach ($this->reverseMapping as $type => $candidates) {
            foreach ($candidates as $candidate) {
                if (is_string($candidate)) {
                    if (strtolower($candidate) == strtolower($this->type)) {
                        return $type;
                    }

                    continue;
                }

                if (strtolower($candidate['type']) != strtolower($this->type)) {
                    continue;
                }

                foreach ($candidate as $option => $required) {
                    if ($option == 'type') {
                        continue;
                    }

                    if ($this->{$option} != $required) {
                        continue 2;
                    }
                }

                return $type;
            }
        }

        return 'unknown';
    }
275284
static public function detectClientType()
    {
        $clientType       = static::PC;
        if (HttpHelper::isMobile()) {
            if (HttpHelper::isWechat()) {
                $clientType = static::WX;
            } elseif (HttpHelper::isAlipay()) {
                $clientType = static::ALIPAY;
            } else {
                $clientType = static::MOBILE;
            }
        }
        
        return $clientType;
    }