Httx

⚡️ X-Force HTTP/REST library for Unity ⚡️

* Zero dependency, built for **Unity** * **Simple**, DSL-like API to compose your requests * Includes reliable memory, disk and native AssetBundle **cache** support * Easily **extensible** for your custom needs ## Quick Start You need **Unity 2019.x** or newer ### Install Httx with Package Manger (NPM Package) Httx distributed as standard [Unity Package](https://docs.unity3d.com/Manual/PackagesList.html) You can install this package using Unity Package Manager, just add the following to your `Packages/manifest.json`: Add official [NPM](https://www.npmjs.com/) registry with WhiteSharx scope, or simply add `com.whitesharx` scope if you already have NPM registry added: ```json { "scopedRegistries": [ { "name": "Official NPM Registry", "url": "https://registry.npmjs.org/", "scopes": [ "com.whitesharx" ] } ] } ``` Add `com.whitesharx.httx` package to your dependencies (see repo tags to pick the version): ```json { "dependencies": { "com.whitesharx.httx": "x.x.x" } } ``` ### Install Httx with Package Manger (Git url) Or, your can simply install it from git url (see repo tags to pick the version): ```json { "dependencies": { "com.whitesharx.httx": "https://github.com/whitesharx/httx.git#x.x.x" } } ``` ### Add preserve rule for linker Preserve `Httx` assembly contents in your `Assets/link.xml`: ```xml ``` ### Initialize context First, you need to initaize `Context` to make HTTP requests. If you do not need any fine-tune customization it's just one line of code: ```csharp Context.InitializeDefault(1, () => { /* Ready to go callback */ }); ``` To give you more detailed example, suppose you want to do it from MonoBehaviour: ```csharp public class YourMonoBehaviour : MonoBehaviour { // XXX: Versioning exists to manage caching. private const int Version = 1; private void Awake() { Context.InitializeDefault(Version, OnContextReady); } private async void OnContextReady() { // Here you can safely make HTTP requests using Httx. } } ``` ### Make your first HTTP requests Now you are ready to make HTTP requests. Suppose you realized that you desperetly need to download whole Google...as text. Here you go: ```csharp var text = await new As(new Get(new Text("https://google.com"))); ``` Ok, that's was fun. But now, let's take a look at more serious stuff you can do with Httx starting with simple requests: ```csharp // Make simple GET request for text data. var text = await new As(new Get(new Text(url))); // Make GET request for JSON data and parse it to your model with default JSONUtility. var user = await new As(new Get(new Json(url))); // Make POST request with JSON payload and parse JSON model as response. var credentials = await new As(new Post(new Json(url, new User("John Doe")))); ``` Take a look at some even more complicated stuff: ```csharp // Make POST request that requires basic authorization. var token = await new As(new Post(new Basic(new Json(url, user), name, password))); // Make POST request that requires bearer authorization. var credentials = await new As(new Put(new Bearer(new Json(url, user), token))); ``` Highly decorated requests become a bit messy. You can use **Fluent API** to build more complex requests. You can rewrite two requests above with Fluent API like this: ```csharp // Make POST request that requires basic authorization. var token = await new Json(url, user) .Post() .Basic(name, password) .As(); // Make POST request that requires bearer authorization. var credentials = await new Json(url, user) .Post() .Bearer(token) .As(); ``` Let's examine some caching capabilities. Httx supports **in-memory** and **disk** caching out of the box. Also it supports native Unity **AssetBundle** caching: ```csharp // Download a picture and also cache it on disk. // Next request to this url will be offline. var texture = await new new Texture(url) .Get() .Cache(Storage.Disk) .As(); // Download some "hot" data and cache it for a few seconds in memory. // Requests to this urls made in next 4 seconds will hit only memory in-cache. var bytes = new Bytes(url) .Get() .Cache(Storage.Memory, TimeSpan.FromSeconds(4)) .As(); ``` Httx also supports Unity AssetBundles out of the box: ```csharp // Download asset bundle. Local or remote urls supported. var bundle = await new As(new Get(new Bundle(url))); // Download asset bundle and cache it on disk. Next request will hit offline file. var bundle = await new As(new Cache(new Get(new Bundle(url)), Storage.Native)); // Download asset bundle and display progress while downloading var onProgress = new Progress(value => { /* Implementation */ }); var bundle = await new As(new Get(new Bundle(url), onProgress)); ``` ## Documentation There's more stuff under the hood. Please check detailed documentation and examples to understand how this librarty could fit your needs. * [Documentation](https://github.com/whitesharx/httx/wiki/Home) * [Examples](https://github.com/whitesharx/httx/wiki/Examples) ## License Httx is available under the [MIT](https://en.wikipedia.org/wiki/MIT_License) license.

Made with 🖤 at WhiteSharx