WURFL Microservice Client for Go

https://github.com/wurfl/wurfl-microservice-client-golang
Admin
A Go client library for the WURFL Microservice that detects over 500 mobile device capabilities...
Tokens:9,668
Snippets:51
Trust Score:8.2
Update:7 months ago
Show doc for...
Tokens:
Raw
### Configure HTTP Timeouts and Client Settings in Go

Source: https://context7.com/wurfl/wurfl-microservice-client-golang/llms.txt

Demonstrates how to initialize the WURFL client, set connection and transfer timeouts using SetHTTPTimeout, and configure cache size and requested capabilities. This setup is essential for optimizing performance and ensuring reliable communication with the WM server.

```go
package main

import (
	"fmt"
	"log"
	"strings"

	"github.com/wurfl/wurfl-microservice-client-golang/v2/scientiamobile/wmclient"
)

func main() {
	client, err := wmclient.Create("http", "localhost", "8080", "")
	if err != nil {
		log.Fatal(err)
	}
	defer client.DestroyConnection()

	// Set connection timeout to 5 seconds and transfer timeout to 30 seconds
	client.SetHTTPTimeout(5, 30)

	client.SetCacheSize(100000)
	client.SetRequestedCapabilities(strings.Fields("brand_name model_name"))

	// Now perform lookups with configured timeouts
	deviceData, err := client.LookupUserAgent("Mozilla/5.0 (iPhone; CPU iPhone OS 16_0 like Mac OS X)")
	if err != nil {
		log.Fatal("Lookup failed:", err.Error())
	}

	fmt.Printf("Detected: %s %s\n", deviceData.Capabilities["brand_name"], deviceData.Capabilities["model_name"])
}
```

--------------------------------

### Get Versions for OS - Go

Source: https://github.com/wurfl/wurfl-microservice-client-golang/blob/master/wmclient.md

Retrieves a list of all available versions for a given operating system name. It returns a slice of strings, where each string is an OS version, or an error if the retrieval fails.

```go
import "github.com/wurfl/wurfl-microservice-client-golang/v2/scientiamobile/wmclient"

// ...

// Assuming 'client' is an initialized *wmclient.WmClient
osName := "Android"
osVersions, err := client.GetAllVersionsForOS(osName)
if err != nil {
	// Handle error
}
// Process osVersions

```

--------------------------------

### Get and Print All OS Names using Go Client

Source: https://github.com/wurfl/wurfl-microservice-client-golang/blob/master/README.md

This Go code snippet demonstrates how to retrieve a list of all operating system names from the WM server using the ClientConn.GetAllOSNames() method. It then sorts the names alphabetically and prints them to the console. Error handling is included for the API call.

```go
func main() {
	// ... (previous code)
	oses, err := ClientConn.GetAllOSNames()

	if err != nil {
		log.Fatalf("Error getting device data %s\n", err.Error())
	}

	// Sort and print all OS names
	sort.Strings(oses)

	for _, os := range oses {
		fmt.Printf(" - %s\n", os)
	}
	// ... (subsequent code)
}
```

--------------------------------

### Construct HTTP Request with Headers for Device Detection in Go

Source: https://github.com/wurfl/wurfl-microservice-client-golang/blob/master/README.md

This Go code snippet illustrates how to create an HTTP GET request to 'www.gitub.com' and populate its headers with various fields commonly used for device detection. This includes Content-Type, Accept, Accept-Encoding, Accept-Language, and several custom headers like Device-Stock-Ua, Forwarded, Referer, User-Agent, and X-Operamini-Phone-Ua. The code checks for errors during request creation.

```go
request, err := http.NewRequest("GET", "www.gitub.com", nil)
	if err == nil {
		request.Header.Add("Content-Type", "application/json")
		request.Header.Add("Accept", "text/html, application/xml;q=0.9, application/xhtml+xml, image/png, image/webp, image/jpeg, image/gif, image/x-xbitmap, */*;q=0.1")
		request.Header.Add("Accept-Encoding", "gzip, deflate")
		request.Header.Add("Accept-Language", "en")
		request.Header.Add("Device-Stock-Ua", "Mozilla/5.0 (Linux; Android 8.1.0; SM-J610G Build/M1AJQ; wv) AppleWebKit/537.36 (KHTML, like Gecko) Version/4.0 Chrome/69.0.3497.100 Mobile Safari/537.36")
		request.Header.Add("Forwarded", "for=\"110.54.224.195:36350\"")
		request.Header.Add("Referer", "https://www.cram.com/flashcards/labor-and-delivery-questions-889210")
		request.Header.Add("User-Agent", "Opera/9.80 (Android; Opera Mini/51.0.2254/184.121; U; en) Presto/2.12.423 Version/12.16")
		request.Header.Add("X-Clacks-Overhead", "GNU ph")
		request.Header.Add("X-Forwarded-For", "110.54.224.195, 82.145.210.235")
		request.Header.Add("X-Operamini-Features", "advanced, camera, download, file_system, folding, httpping, pingback, routing, touch, viewport")
		request.Header.Add("X-Operamini-Phone", "Android #")
		request.Header.Add("X-Operamini-Phone-Ua", "Mozilla/5.0 (Linux; Android 8.1.0; SM-J610G Build/M1AJQ; wv) AppleWebKit/537.36 (KHTML, like Gecko) Version/4.0 Chrome/69.0.3497.100 Mobile Safari/537.36")
	}

	JSONDeviceData, callerr := ClientConn.LookupRequest(*request)
```

--------------------------------

### Get All Device Makes - Go

Source: https://github.com/wurfl/wurfl-microservice-client-golang/blob/master/wmclient.md

Fetches a list of all available device 'brand_name' capabilities from the WURFL microservice. It returns a slice of strings, where each string is a device make, or an error if the retrieval fails.

```go
import "github.com/wurfl/wurfl-microservice-client-golang/v2/scientiamobile/wmclient"

// ...

// Assuming 'client' is an initialized *wmclient.WmClient
allMakes, err := client.GetAllDeviceMakes()
if err != nil {
	// Handle error
}
// Process allMakes

```

--------------------------------

### Get and Print Android OS Versions using Go Client

Source: https://github.com/wurfl/wurfl-microservice-client-golang/blob/master/README.md

This Go code snippet shows how to fetch all versions for a specific operating system, in this case, 'Android', from the WM server using ClientConn.GetAllVersionsForOS(). The retrieved versions are then sorted and printed to the console. It includes error handling for the API call.

```go
func main() {
	// ... (previous code)
	// Let's call the WM server to get all version of the Android OS
	fmt.Println("Print all versions for the Android OS")
	versions, err := ClientConn.GetAllVersionsForOS("Android")

	if err != nil {
		log.Fatalf("Error getting device data %s\n", err.Error())
	}

	// Sort all Android version numbers and print them.
	sort.Strings(versions)

	for _, version := range versions {
		fmt.Printf(" - %s\n", version)
	}
}
```

--------------------------------

### Get All Operating Systems - Go

Source: https://github.com/wurfl/wurfl-microservice-client-golang/blob/master/wmclient.md

Fetches a list of all unique operating system names present in the WURFL data. It returns a slice of strings, where each string is an OS name, or an error if the retrieval fails.

```go
import "github.com/wurfl/wurfl-microservice-client-golang/v2/scientiamobile/wmclient"

// ...

// Assuming 'client' is an initialized *wmclient.WmClient
allOSes, err := client.GetAllOSes()
if err != nil {
	// Handle error
}
// Process allOSes

```

--------------------------------

### Get API Version - Go

Source: https://github.com/wurfl/wurfl-microservice-client-golang/blob/master/wmclient.md

Retrieves the version of the WM Client API. This function does not require any input parameters and returns a string representing the API version.

```go
import "github.com/wurfl/wurfl-microservice-client-golang/v2/scientiamobile/wmclient"

// ...

apiVersion := wmclient.GetAPIVersion()

```

--------------------------------

### SetCacheSize - Configure Client-Side Caching

Source: https://context7.com/wurfl/wurfl-microservice-client-golang/llms.txt

Configures the LRU cache size to improve performance by caching device lookups. This example demonstrates setting the cache size, performing lookups, and retrieving cache statistics.

```go
package main

import (
	"fmt"
	"log"
	"strings"

	"github.com/wurfl/wurfl-microservice-client-golang/v2/scientiamobile/wmclient"
)

func main() {
	client, err := wmclient.Create("http", "localhost", "8080", "")
	if err != nil {
		log.Fatal(err)
	}
	defer client.DestroyConnection()

	// Enable caching with 100,000 entry limit for user-agent cache
	client.SetCacheSize(100000)

	client.SetRequestedCapabilities(strings.Fields("brand_name model_name"))

	ua := "Mozilla/5.0 (iPhone; CPU iPhone OS 16_0 like Mac OS X)"

	// First lookup - cache miss, fetches from server
	_, _ = client.LookupUserAgent(ua)

	// Second lookup - cache hit, returns immediately
	_, _ = client.LookupUserAgent(ua)

	// Get current cache sizes
	deviceCacheSize, uaCacheSize := client.GetActualCacheSizes()
	fmt.Printf("Device ID cache entries: %d\n", deviceCacheSize)
	fmt.Printf("User-Agent cache entries: %d\n", uaCacheSize)

	// Get cache statistics
	stats, _ := client.GetCacheStats()
	fmt.Printf("UA Cache hits: %d\n", stats.UserAgentCacheHits)
	fmt.Printf("UA Cache misses: %d\n", stats.UserAgentCacheMisses)
}
```

--------------------------------

### Get Devices for Make - Go

Source: https://github.com/wurfl/wurfl-microservice-client-golang/blob/master/wmclient.md

Retrieves a list of devices associated with a specific brand name. For each device, it returns a JSONModelMktName object containing the model name and marketing name. An error is returned if the operation fails.

```go
import "github.com/wurfl/wurfl-microservice-client-golang/v2/scientiamobile/wmclient"

// ...

// Assuming 'client' is an initialized *wmclient.WmClient
brandName := "Apple"
devices, err := client.GetAllDevicesForMake(brandName)
if err != nil {
	// Handle error
}
// Process devices

```

--------------------------------

### LookupRequest - Detect Device from HTTP Request (Go)

Source: https://context7.com/wurfl/wurfl-microservice-client-golang/llms.txt

Performs device detection using all HTTP headers from an incoming request. This method automatically extracts important headers for accurate detection. The example sets up an HTTP server that listens for requests, performs detection, and returns the results as JSON. Dependencies include the 'github.com/wurfl/wurfl-microservice-client-golang/v2' package and standard Go libraries for HTTP handling.

```go
package main

import (
	"encoding/json"
	"fmt"
	"log"
	"net/http"
	"strings"

	"github.com/wurfl/wurfl-microservice-client-golang/v2/scientiamobile/wmclient"
)

func main() {
	client, err := wmclient.Create("http", "localhost", "8080", "")
	if err != nil {
		log.Fatal(err)
	}

	client.SetCacheSize(100000)
	client.SetRequestedCapabilities(strings.Fields("brand_name model_name is_smartphone form_factor is_tablet"))

	// Create an HTTP server that detects devices
	http.HandleFunc("/detect", func(w http.ResponseWriter, r *http.Request) {
		deviceData, err := client.LookupRequest(*r)
		if err != nil {
			http.Error(w, err.Error(), http.StatusInternalServerError)
			return
		}

		w.Header().Set("Content-Type", "application/json")
		json.NewEncoder(w).Encode(map[string]interface{}{
			"wurfl_id":      deviceData.Capabilities["wurfl_id"],
			"brand_name":    deviceData.Capabilities["brand_name"],
			"model_name":    deviceData.Capabilities["model_name"],
			"is_smartphone": deviceData.Capabilities["is_smartphone"],
			"form_factor":   deviceData.Capabilities["form_factor"],
		})
	})

	fmt.Println("Starting device detection server on :9090")
	log.Fatal(http.ListenAndServe(":9090", nil))
}

// Test with curl:
// curl -H "User-Agent: Mozilla/5.0 (Linux; Android 13; SM-S918B) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/120.0.0.0 Mobile Safari/537.36" http://localhost:9090/detect
// Response: {"brand_name":"Samsung","form_factor":"Smartphone","is_smartphone":"true","model_name":"SM-S918B","wurfl_id":"samsung_sm_s918b_ver1"}
```

--------------------------------

### Get WURFL Server Info - Go

Source: https://github.com/wurfl/wurfl-microservice-client-golang/blob/master/wmclient.md

Retrieves general information about the running WURFL microservice and its API. It returns a JSONInfoData object containing details like WURFL API version, server info, WM version, and capability lists, or an error.

```go
import "github.com/wurfl/wurfl-microservice-client-golang/v2/scientiamobile/wmclient"

// ...

// Assuming 'client' is an initialized *wmclient.WmClient
info, err := client.GetInfo()
if err != nil {
	// Handle error
}
// Process info

```

--------------------------------

### Get WURFL Cache Sizes - Go

Source: https://github.com/wurfl/wurfl-microservice-client-golang/blob/master/wmclient.md

Retrieves the current sizes of the WURFL client's internal caches. It returns two integer values: the size of the device-ID based cache and the size of the headers-based cache.

```go
import "github.com/wurfl/wurfl-microservice-client-golang/v2/scientiamobile/wmclient"

// ...

// Assuming 'client' is an initialized *wmclient.WmClient
deviceCacheSize, headersCacheSize := client.GetActualCacheSizes()

```

--------------------------------

### Initialize and Use WURFL Microservice Client in Go

Source: https://github.com/wurfl/wurfl-microservice-client-golang/blob/master/README.md

Demonstrates how to initialize the WURFL Microservice client, configure caching, retrieve server information, set desired capabilities, perform user agent lookups, and fetch lists of device manufacturers, models, and operating systems. It requires the WURFL Microservice to be running and accessible.

```go
package main

import (
	"fmt"
	"log"
	"sort"
	"strings"

	"github.com/wurfl/wurfl-microservice-client-golang/v2/scientiamobile/wmclient"
)

// Implements sort.Interface for []wmclient.JSONModelMktName
type ByModelName []wmclient.JSONModelMktName

func (c ByModelName) Len() int {
	return len(c)
}

func (c ByModelName) Swap(i, j int) {
	c[i], c[j] = c[j], c[i]
}
func (c ByModelName) Less(i, j int) bool {
	return c[i].ModelName < c[j].ModelName
}

func main() {
	var err error

	// First we need to create a WM client instance, to connect to our WM server API at the specified host and port.
	ClientConn, err := wmclient.Create("http", "localhost", "80", "")
	if err != nil {
		// problems such as network errors  or internal server problems
		log.Fatal("wmclient.Create returned :", err.Error())
	}
	// By setting the cache size we are also activating the caching option in WM client. In order to not use cache, you just to need to omit setCacheSize call
	ClientConn.SetCacheSize(100000)

	// We ask Wm server API for some Wm server info such as server API version and info about WURFL API and file used by WM server.
	info, ierr := ClientConn.GetInfo()
	if ierr != nil {
		fmt.Println("Error getting server info: " + ierr.Error())
	} else {
		fmt.Println("WURFL Microservice information:")
		fmt.Println("Server version: " + info.WmVersion)
		fmt.Println("WURFL API version: " + info.WurflAPIVersion)
		fmt.Printf("WURFL file info: %s \n", info.WurflInfo)
	}

	// set the capabilities we want to receive from WM server
	// Static capabilities
	sCapsList := strings.Fields("model_name brand_name")
	// Virtual capabilities
	vCapsList := strings.Fields("is_smartphone form_factor")
	ClientConn.SetRequestedStaticCapabilities(sCapsList)
	ClientConn.SetRequestedVirtualCapabilities(vCapsList)

	ua := "Mozilla/5.0 (iPhone; CPU iPhone OS 5_0 like Mac OS X) AppleWebKit/534.46 (KHTML, like Gecko) Version/5.1 Mobile/9A334 Safari/7534.48.3"

	// Perform a device detection calling WM server API
	JSONDeviceData, callerr := ClientConn.LookupUserAgent(ua)

	if callerr != nil {
		// Applicative error, ie: invalid input provided
		log.Fatalf("Error getting device data %s\n", callerr.Error())
	}

	// Let's get the device capabilities and print some of them
	fmt.Printf("WURFL device id : %s\n", JSONDeviceData.Capabilities["wurfl_id"])

	// print brand & model (static capabilities)
	fmt.Printf("This device is a : %s %s\n", JSONDeviceData.Capabilities["brand_name"], JSONDeviceData.Capabilities["model_name"])

	// check if device is a smartphone (a virtual capability)
	if JSONDeviceData.Capabilities["is_smartphone"] == "true" {
		fmt.Println("This is a smartphone")
	}
	fmt.Printf("This device form_factor is %s\n", JSONDeviceData.Capabilities["form_factor"])

	// Get all the device manufacturers, and print the first twenty
	deviceMakes, err := ClientConn.GetAllDeviceMakes()
	if err != nil {
		log.Fatalf("Error getting device data %s\n", err.Error())
	}

	var limit = 20
	fmt.Printf("Print the first %d Brand of %d\n", limit, len(deviceMakes))

	// Sort the device manufacturer names
	sort.Strings(deviceMakes)

	for _, deviceMake := range deviceMakes[0:limit] {
		fmt.Printf(" - %s\n", deviceMake)
	}

	// Now call the WM server to get all device model and marketing names produced by Apple
	fmt.Println("Print all Model for the Apple Brand")
	modelMktNames, err := ClientConn.GetAllDevicesForMake("Apple")

	if err != nil {
		log.Fatalf("Error getting device data %s\n", err.Error())
	}

	// Sort modelMktNames objects by their model name
	sort.Sort(ByModelName(modelMktNames))

	for _, modelMktName := range modelMktNames {
		fmt.Printf(" - %s %s\n", modelMktName.ModelName, modelMktName.MarketingName)
	}

	// Now call the WM server to get all operative system names
	fmt.Println("Print the list of OSes")
	oses, err := ClientConn.GetAllOSes()

	if err != nil {
		log.Fatalf("Error getting device data %s\n", err.Error())
	}

	for _, os := range oses {
		fmt.Printf(" - %s\n", os)
	}
}

```

--------------------------------

### GetAllDevicesForMake - List Devices by Manufacturer

Source: https://context7.com/wurfl/wurfl-microservice-client-golang/llms.txt

Retrieves all device models and marketing names for a specified manufacturer. The output is sorted by model name to ensure consistent display.

```go
package main

import (
	"fmt"
	"log"
	"sort"

	"github.com/wurfl/wurfl-microservice-client-golang/v2/scientiamobile/wmclient"
)

// Implements sort.Interface for []wmclient.JSONModelMktName
type ByModelName []wmclient.JSONModelMktName

func (c ByModelName) Len() int           { return len(c) }
func (c ByModelName) Swap(i, j int)      { c[i], c[j] = c[j], c[i] }
func (c ByModelName) Less(i, j int) bool { return c[i].ModelName < c[j].ModelName }

func main() {
	client, err := wmclient.Create("http", "localhost", "8080", "")
	if err != nil {
		log.Fatal(err)
	}
	defer client.DestroyConnection()

	models, err := client.GetAllDevicesForMake("Apple")
	if err != nil {
		log.Fatal("Error:", err.Error())
	}

	sort.Sort(ByModelName(models))

	fmt.Printf("Total Apple devices: %d\n", len(models))
	fmt.Println("Sample devices:")
	for _, model := range models[:5] {
		if model.MarketingName != "" {
			fmt.Printf("  - %s (%s)\n", model.ModelName, model.MarketingName)
		} else {
			fmt.Printf("  - %s\n", model.ModelName)
		}
	}
}
```

--------------------------------

### Create WmClient Connection in Go

Source: https://context7.com/wurfl/wurfl-microservice-client-golang/llms.txt

Establishes a connection to a WURFL Microservice (WM) server and initializes a WmClient instance. It validates the connection by fetching server information and populates available static and virtual capabilities. Requires the 'github.com/wurfl/wurfl-microservice-client-golang/v2/scientiamobile/wmclient' package.

```go
package main

import (
	"fmt"
	"log"

	"github.com/wurfl/wurfl-microservice-client-golang/v2/scientiamobile/wmclient"
)

func main() {
	// Create client connection to WM server
	// Parameters: scheme, host, port, baseURI (empty string if not needed)
	client, err := wmclient.Create("http", "localhost", "8080", "")
	if err != nil {
		log.Fatal("Failed to connect to WM server:", err.Error())
	}
	defer client.DestroyConnection()

	fmt.Println("Successfully connected to WM server")
	fmt.Printf("API Version: %s\n", wmclient.GetAPIVersion())
	// Output: API Version: 2.2.0
}
```

--------------------------------

### GetAllOSes - List All Operating Systems

Source: https://context7.com/wurfl/wurfl-microservice-client-golang/llms.txt

Fetches a comprehensive list of all operating systems available in the WURFL database. The results are sorted alphabetically for easier navigation.

```go
package main

import (
	"fmt"
	"log"
	"sort"

	"github.com/wurfl/wurfl-microservice-client-golang/v2/scientiamobile/wmclient"
)

func main() {
	client, err := wmclient.Create("http", "localhost", "8080", "")
	if err != nil {
		log.Fatal(err)
	}
	defer client.DestroyConnection()

	oses, err := client.GetAllOSes()
	if err != nil {
		log.Fatal("Error:", err.Error())
	}

	sort.Strings(oses)

	fmt.Printf("Total operating systems: %d\n", len(oses))
	fmt.Println("Operating systems:")
	for _, os := range oses {
		fmt.Printf("  - %s\n", os)
	}
}
```

--------------------------------

### Configure Requested Capabilities in Go

Source: https://context7.com/wurfl/wurfl-microservice-client-golang/llms.txt

Sets which device capabilities (static and virtual) should be returned in lookup responses. This method automatically categorizes capabilities based on server support. It also provides functions to check if a specific static or virtual capability is available. Requires an active WmClient connection.

```go
package main

import (
	"fmt"
	"log"
	"strings"

	"github.com/wurfl/wurfl-microservice-client-golang/v2/scientiamobile/wmclient"
)

func main() {
	client, err := wmclient.Create("http", "localhost", "8080", "")
	if err != nil {
		log.Fatal(err)
	}
	defer client.DestroyConnection()

	// Set capabilities to retrieve (mixed static and virtual)

capsList := strings.Fields("brand_name model_name is_smartphone form_factor device_os is_tablet")
	client.SetRequestedCapabilities(capsList)

	// Alternatively, set static and virtual capabilities separately
	staticCaps := []string{"brand_name", "model_name", "device_os"}
	virtualCaps := []string{"is_smartphone", "form_factor", "is_tablet"}
	client.SetRequestedStaticCapabilities(staticCaps)
	client.SetRequestedVirtualCapabilities(virtualCaps)

	// Check if a capability exists
	fmt.Printf("Has 'brand_name' static cap: %v\n", client.HasStaticCapability("brand_name"))
	fmt.Printf("Has 'is_smartphone' virtual cap: %v\n", client.HasVirtualCapability("is_smartphone"))
	// Output:
	// Has 'brand_name' static cap: true
	// Has 'is_smartphone' virtual cap: true
}
```

--------------------------------

### Retrieve Server Information with GetInfo in Go

Source: https://context7.com/wurfl/wurfl-microservice-client-golang/llms.txt

Fetches detailed information about the running WURFL Microservice server using the GetInfo method. This includes the server version, WURFL API version, available capabilities (static and virtual), and important headers used for device detection. Requires an active WmClient connection.

```go
package main

import (
	"fmt"
	"log"

	"github.com/wurfl/wurfl-microservice-client-golang/v2/scientiamobile/wmclient"
)

func main() {
	client, err := wmclient.Create("http", "localhost", "8080", "")
	if err != nil {
		log.Fatal(err)
	}
	defer client.DestroyConnection()

	info, err := client.GetInfo()
	if err != nil {
		log.Fatal("Error getting server info:", err.Error())
	}

	fmt.Println("WURFL Microservice Information:")
	fmt.Printf("Server version: %s\n", info.WmVersion)
	fmt.Printf("WURFL API version: %s\n", info.WurflAPIVersion)
	fmt.Printf("WURFL file info: %s\n", info.WurflInfo)
	fmt.Printf("Important headers: %v\n", info.ImportantHeaders)
	fmt.Printf("Static capabilities count: %d\n", len(info.StaticCaps))
	fmt.Printf("Virtual capabilities count: %d\n", len(info.VirtualCaps))
	// Output:
	// WURFL Microservice Information:
	// Server version: 2.3.0
	// WURFL API version: 1.12.7.0
	// WURFL file info: wurfl.xml - 2024-01-15
	// Important headers: [User-Agent X-UCBrowser-Device-UA Device-Stock-UA ...]
}
```

--------------------------------

### Create WURFL Microservice Client - Go

Source: https://github.com/wurfl/wurfl-microservice-client-golang/blob/master/wmclient.md

Initializes and creates a new WURFL Microservice client instance. It requires the scheme (e.g., "http", "https"), host, port, and base URI of the WURFL microservice. It returns a pointer to the WmClient and an error if the server is not accessible.

```go
import (
	"net/http"
	"github.com/wurfl/wurfl-microservice-client-golang/v2/scientiamobile/wmclient"
)

// ...

client, err := wmclient.Create("http", "localhost", "8080", "/api/v1")
if err != nil {
	// Handle error
}
// Use the client

```

--------------------------------

### GetAllVersionsForOS - List OS Versions

Source: https://context7.com/wurfl/wurfl-microservice-client-golang/llms.txt

Retrieves all known versions for a specific operating system. This is useful for identifying specific OS releases within the WURFL dataset.

```go
package main

import (
	"fmt"
	"log"
	"sort"

	"github.com/wurfl/wurfl-microservice-client-golang/v2/scientiamobile/wmclient"
)

func main() {
	client, err := wmclient.Create("http", "localhost", "8080", "")
	if err != nil {
		log.Fatal(err)
	}
	defer client.DestroyConnection()

	versions, err := client.GetAllVersionsForOS("Android")
	if err != nil {
		log.Fatal("Error:", err.Error())
	}

	sort.Strings(versions)

	fmt.Printf("Total Android versions: %d\n", len(versions))
	fmt.Println("Android versions (last 10):")
	for _, version := range versions[len(versions)-10:] {
		fmt.Printf("  - Android %s\n", version)
	}
}
```

--------------------------------

### LookupUserAgent - Detect Device by User-Agent String (Go)

Source: https://context7.com/wurfl/wurfl-microservice-client-golang/llms.txt

Performs device detection using a user-agent string. It initializes the WURFL client, sets caching and requested capabilities, and then looks up the device. The output includes various device attributes like brand, model, and OS. Dependencies include the 'github.com/wurfl/wurfl-microservice-client-golang/v2' package.

```go
package main

import (
	"fmt"
	"log"
	"strings"

	"github.com/wurfl/wurfl-microservice-client-golang/v2/scientiamobile/wmclient"
)

func main() {
	client, err := wmclient.Create("http", "localhost", "8080", "")
	if err != nil {
		log.Fatal(err)
	}
	defer client.DestroyConnection()

	// Enable caching for better performance
	client.SetCacheSize(100000)

	// Configure capabilities
	client.SetRequestedCapabilities(strings.Fields("brand_name model_name is_smartphone form_factor device_os"))

	// iPhone user-agent
	ua := "Mozilla/5.0 (iPhone; CPU iPhone OS 16_0 like Mac OS X) AppleWebKit/605.1.15 (KHTML, like Gecko) Version/16.0 Mobile/15E148 Safari/604.1"

	deviceData, err := client.LookupUserAgent(ua)
	if err != nil {
		log.Fatal("Lookup error:", err.Error())
	}

	fmt.Printf("WURFL ID: %s\n", deviceData.Capabilities["wurfl_id"])
	fmt.Printf("Brand: %s\n", deviceData.Capabilities["brand_name"])
	fmt.Printf("Model: %s\n", deviceData.Capabilities["model_name"])
	fmt.Printf("Is Smartphone: %s\n", deviceData.Capabilities["is_smartphone"])
	fmt.Printf("Form Factor: %s\n", deviceData.Capabilities["form_factor"])
	fmt.Printf("Device OS: %s\n", deviceData.Capabilities["device_os"])
}
```

--------------------------------

### POST /lookupRequest

Source: https://context7.com/wurfl/wurfl-microservice-client-golang/llms.txt

Performs device detection by analyzing all headers from an incoming HTTP request. This method is recommended for live web traffic as it utilizes multiple device hints for higher accuracy.

```APIDOC
## POST /lookupRequest

### Description
Performs device detection using all HTTP headers from an incoming request. This method extracts important headers automatically and provides the most accurate detection results.

### Method
POST

### Endpoint
/lookupRequest

### Parameters
#### Request Body
- **headers** (object) - Required - The full set of HTTP request headers.

### Request Example
{
  "headers": {
    "User-Agent": "Mozilla/5.0 (Linux; Android 13; SM-S918B)...",
    "Accept": "text/html,application/xhtml+xml..."
  }
}

### Response
#### Success Response (200)
- **capabilities** (object) - Map of detected device capabilities.

#### Response Example
{
  "brand_name": "Samsung",
  "form_factor": "Smartphone",
  "is_smartphone": "true",
  "model_name": "SM-S918B",
  "wurfl_id": "samsung_sm_s918b_ver1"
}
```

--------------------------------

### POST /lookupUserAgent

Source: https://context7.com/wurfl/wurfl-microservice-client-golang/llms.txt

Performs device detection based on a provided user-agent string. This is useful for offline processing or when the full HTTP request object is not available.

```APIDOC
## POST /lookupUserAgent

### Description
Performs device detection using a user-agent string. Returns device capabilities including brand, model, operating system, and other configured attributes.

### Method
POST

### Endpoint
/lookupUserAgent

### Parameters
#### Request Body
- **user_agent** (string) - Required - The User-Agent string to analyze.

### Request Example
{
  "user_agent": "Mozilla/5.0 (iPhone; CPU iPhone OS 16_0 like Mac OS X)..."
}

### Response
#### Success Response (200)
- **capabilities** (object) - Map of requested device capabilities (e.g., brand_name, model_name, is_smartphone).

#### Response Example
{
  "wurfl_id": "apple_iphone_ver16",
  "brand_name": "Apple",
  "model_name": "iPhone",
  "is_smartphone": "true"
}
```

--------------------------------

### GetAllDeviceMakes - List All Device Manufacturers

Source: https://context7.com/wurfl/wurfl-microservice-client-golang/llms.txt

Returns a list of all device brand names (manufacturers) available in the WURFL database.

```go
package main

import (
	"fmt"
	"log"
	"sort"

	"github.com/wurfl/wurfl-microservice-client-golang/v2/scientiamobile/wmclient"
)

func main() {
	client, err := wmclient.Create("http", "localhost", "8080", "")
	if err != nil {
		log.Fatal(err)
	}
	defer client.DestroyConnection()

	deviceMakes, err := client.GetAllDeviceMakes()
	if err != nil {
		log.Fatal("Error:", err.Error())
	}

	sort.Strings(deviceMakes)

	fmt.Printf("Total device manufacturers: %d\n", len(deviceMakes))
	fmt.Println("First 10 brands:")
	for i, make := range deviceMakes[:10] {
		fmt.Printf("  %d. %s\n", i+1, make)
	}
}
```

--------------------------------

### Lookup Device by HTTP Request - Go

Source: https://github.com/wurfl/wurfl-microservice-client-golang/blob/master/wmclient.md

Detects a device based on the information present in an HTTP request (e.g., User-Agent header). It returns the device's data in JSON format (JSONDeviceData) or an error if detection fails.

```go
import (
	"net/http"
	"github.com/wurfl/wurfl-microservice-client-golang/v2/scientiamobile/wmclient"
)

// ...

// Assuming 'client' is an initialized *wmclient.WmClient and 'req' is an *http.Request
deviceData, err := client.LookupRequest(*req)
if err != nil {
	// Handle error
}
// Process deviceData

```

--------------------------------

### Set Requested Static Capabilities for Wurfl Go Client

Source: https://github.com/wurfl/wurfl-microservice-client-golang/blob/master/wmclient.md

Use SetRequestedStaticCapabilities to define a list of standard static capabilities that the client should retrieve. This is useful for fetching commonly used, unchanging device information.

```go
func (c *WmClient) SetRequestedStaticCapabilities(CapsList []string)
// SetRequestedStaticCapabilities - set list of standard static capabilities to
// return
```

--------------------------------

### Lookup Device by User Agent - Go

Source: https://github.com/wurfl/wurfl-microservice-client-golang/blob/master/wmclient.md

Searches for WURFL device data using a provided User-Agent string. It returns a JSONDeviceData object containing the device's capabilities, or an error if the lookup fails.

```go
import "github.com/wurfl/wurfl-microservice-client-golang/v2/scientiamobile/wmclient"

// ...

// Assuming 'client' is an initialized *wmclient.WmClient
userAgent := "Mozilla/5.0 (Linux; Android 10; SM-G975F) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/83.0.4103.106 Mobile Safari/537.36"
deviceData, err := client.LookupUserAgent(userAgent)
if err != nil {
	// Handle error
}
// Process deviceData

```

--------------------------------

### LookupHeaders - Detect Device from Header Map

Source: https://context7.com/wurfl/wurfl-microservice-client-golang/llms.txt

Performs device detection using a map of HTTP headers. This is useful when headers are available as key-value pairs rather than an http.Request object.

```go
package main

import (
	"fmt"
	"log"
	"strings"

	"github.com/wurfl/wurfl-microservice-client-golang/v2/scientiamobile/wmclient"
)

func main() {
	client, err := wmclient.Create("http", "localhost", "8080", "")
	if err != nil {
		log.Fatal(err)
	}
	defer client.DestroyConnection()

	client.SetCacheSize(100000)
	client.SetRequestedCapabilities(strings.Fields("brand_name model_name is_smartphone form_factor"))

	headers := map[string]string{
		"User-Agent":             "Opera/9.80 (Android; Opera Mini/51.0.2254/184.121; U; en) Presto/2.12.423 Version/12.16",
		"Device-Stock-Ua":        "Mozilla/5.0 (Linux; Android 8.1.0; SM-J610G Build/M1AJQ; wv) AppleWebKit/537.36 (KHTML, like Gecko) Version/4.0 Chrome/69.0.3497.100 Mobile Safari/537.36",
		"X-Operamini-Phone-Ua":   "Mozilla/5.0 (Linux; Android 8.1.0; SM-J610G Build/M1AJQ; wv) AppleWebKit/537.36 (KHTML, like Gecko) Version/4.0 Chrome/69.0.3497.100 Mobile Safari/537.36",
		"X-Forwarded-For":        "110.54.224.195, 82.145.210.235",
	}

	deviceData, err := client.LookupHeaders(headers)
	if err != nil {
		log.Fatal("Lookup error:", err.Error())
	}

	fmt.Printf("Detected Device: %s %s\n", deviceData.Capabilities["brand_name"], deviceData.Capabilities["model_name"])
	fmt.Printf("Is Smartphone: %s\n", deviceData.Capabilities["is_smartphone"])
}
```

--------------------------------

### Check Static Capability Existence - Go

Source: https://github.com/wurfl/wurfl-microservice-client-golang/blob/master/wmclient.md

Determines if a given capability name exists within the client's configured static capabilities. Returns true if the capability is present, false otherwise.

```go
import "github.com/wurfl/wurfl-microservice-client-golang/v2/scientiamobile/wmclient"

// ...

// Assuming 'client' is an initialized *wmclient.WmClient
capName := "brand_name"
hasCap := client.HasStaticCapability(capName)

```

--------------------------------

### Check Virtual Capability Existence - Go

Source: https://github.com/wurfl/wurfl-microservice-client-golang/blob/master/wmclient.md

Determines if a given capability name exists within the client's configured virtual capabilities. Returns true if the capability is present, false otherwise.

```go
import "github.com/wurfl/wurfl-microservice-client-golang/v2/scientiamobile/wmclient"

// ...

// Assuming 'client' is an initialized *wmclient.WmClient
capName := "is_tablet"
hasVCap := client.HasVirtualCapability(capName)

```

--------------------------------

### Lookup Device by ID - Go

Source: https://github.com/wurfl/wurfl-microservice-client-golang/blob/master/wmclient.md

Searches for WURFL device data using a specific WURFL ID. It returns a JSONDeviceData object containing the device's capabilities and other information, or an error if the lookup fails.

```go
import "github.com/wurfl/wurfl-microservice-client-golang/v2/scientiamobile/wmclient"

// ...

// Assuming 'client' is an initialized *wmclient.WmClient
deviceID := "generic_android_device"
deviceData, err := client.LookupDeviceID(deviceID)
if err != nil {
	// Handle error
}
// Process deviceData

```

--------------------------------

### Set Requested Capabilities for Wurfl Go Client

Source: https://github.com/wurfl/wurfl-microservice-client-golang/blob/master/wmclient.md

The SetRequestedCapabilities function enables you to specify which capability names the client should request from the Wurfl service. This allows for fine-grained control over the data retrieved.

```go
func (c *WmClient) SetRequestedCapabilities(CapsList []string)
// SetRequestedCapabilities - set the given capability names to the set they belong
```

--------------------------------

### Set Requested Virtual Capabilities for Wurfl Go Client

Source: https://github.com/wurfl/wurfl-microservice-client-golang/blob/master/wmclient.md

The SetRequestedVirtualCapabilities function allows you to specify a list of virtual capabilities to be returned by the Wurfl service. Virtual capabilities are dynamically generated based on device information.

```go
func (c *WmClient) SetRequestedVirtualCapabilities(CapsList []string)
// SetRequestedVirtualCapabilities - set list of virtual capabilities to return
```

--------------------------------

### Set HTTP Timeouts for Wurfl Go Client

Source: https://github.com/wurfl/wurfl-microservice-client-golang/blob/master/wmclient.md

The SetHTTPTimeout function configures the connection and transfer timeouts in seconds for the Wurfl client. It's crucial to call this before establishing any connection to the WM server to prevent indefinite waits.

```go
func (c *WmClient) SetHTTPTimeout(connection int, transfer int)
// SetHTTPTimeout sets the connection and transfer timeouts for this client in
// seconds. This function should be called before performing any connection to WM
// server
```

--------------------------------

### Set Cache Size for Wurfl Go Client

Source: https://github.com/wurfl/wurfl-microservice-client-golang/blob/master/wmclient.md

The SetCacheSize function allows you to configure the maximum number of User-Agent entries to be stored in the client's cache. This is useful for managing memory usage and performance.

```go
func (c *WmClient) SetCacheSize(uaMaxEntries int)
// SetCacheSize : set UA cache size
```

--------------------------------

### LookupDeviceID - Lookup by WURFL Device ID

Source: https://context7.com/wurfl/wurfl-microservice-client-golang/llms.txt

Retrieves device data directly using a known WURFL device ID. This is useful for looking up specific device profiles or when the device ID has been previously stored.

```go
package main

import (
	"fmt"
	"log"
	"strings"

	"github.com/wurfl/wurfl-microservice-client-golang/v2/scientiamobile/wmclient"
)

func main() {
	client, err := wmclient.Create("http", "localhost", "8080", "")
	if err != nil {
		log.Fatal(err)
	}
	defer client.DestroyConnection()

	client.SetCacheSize(100000)
	client.SetRequestedCapabilities(strings.Fields("brand_name model_name marketing_name is_smartphone resolution_width resolution_height"))

	deviceData, err := client.LookupDeviceID("apple_iphone_ver14")
	if err != nil {
		log.Fatal("Lookup error:", err.Error())
	}

	fmt.Printf("WURFL ID: %s\n", deviceData.Capabilities["wurfl_id"])
	fmt.Printf("Brand: %s\n", deviceData.Capabilities["brand_name"])
	fmt.Printf("Model: %s\n", deviceData.Capabilities["model_name"])
	fmt.Printf("Resolution: %sx%s\n", deviceData.Capabilities["resolution_width"], deviceData.Capabilities["resolution_height"])
}
```

--------------------------------

### Destroy WURFL Client Connection - Go

Source: https://github.com/wurfl/wurfl-microservice-client-golang/blob/master/wmclient.md

Disposes of resources associated with the WURFL Microservice client connection. This includes clearing caches and other shared data structures to free up memory and resources.

```go
import "github.com/wurfl/wurfl-microservice-client-golang/v2/scientiamobile/wmclient"

// ...

// Assuming 'client' is an initialized *wmclient.WmClient
client.DestroyConnection()

```
Tokens:
Raw