# ion

**Repository Path**: HarmonyOS-tpc/ion

## Basic Information

- **Project Name**: ion
- **Description**: openharmony Asynchronous Networking and Image Loading*
- **Primary Language**: Unknown
- **License**: Apache-2.0
- **Default Branch**: master
- **Homepage**: None
- **GVP Project**: No

## Statistics

- **Stars**: 10
- **Forks**: 2
- **Created**: 2021-02-23
- **Last Updated**: 2025-05-07

## Categories & Tags

**Categories**: harmony

**Tags**: None

## README

### openharmony Asynchronous Networking and Image Loading*

 * 支持加载并多种方式裁剪显示图片文件
 * 支持加载json字符串
 * 支持加载显示本地media和rawfile资源图片文件
 * 不支持为图片加载前、加载中和加载失败添加占位图
 * 不支持图片加载动画效果
 
 ### 集成配置
 ```
 添加中心仓库
 allprojects{
     repositories{
         mavenCentral()
     }
 }
 添加如下依赖配置
 implementation 'io.openharmony.tpc.thirdlib:ion-core:1.0.4'  
 ```
 
#### Get JSON

```
Ion.with(context)
.load("http://example.com/thing.json")
.asJsonObject()
.setCallback(new FutureCallback<JsonObject>() {
   @Override
    public void onCompleted(Exception e, JsonObject result) {
        // do stuff with the result or error
    }
});
```

#### Post JSON and read JSON

```
JsonObject json = new JsonObject();
json.addProperty("foo", "bar");

Ion.with(context)
.load("http://example.com/post")
.setJsonObjectBody(json)
.asJsonObject()
.setCallback(new FutureCallback<JsonObject>() {
   @Override
    public void onCompleted(Exception e, JsonObject result) {
        // do stuff with the result or error
    }
});
```

#### Post application/x-www-form-urlencoded and read a String

```
Ion.with(getContext())
.load("https://koush.clockworkmod.com/test/echo")
.setBodyParameter("goop", "noop")
.setBodyParameter("foo", "bar")
.asString()
.setCallback(...)
```

#### Post multipart/form-data and read JSON with an upload progress bar

```
Ion.with(getContext())
.load("https://koush.clockworkmod.com/test/echo")
.uploadProgressBar(uploadProgressBar)
.setMultipartParameter("goop", "noop")
.setMultipartFile("archive", "application/zip", new File("/sdcard/filename.zip"))
.asJsonObject()
.setCallback(...)
```

#### Download a File with a progress bar

```
Ion.with(context)
.load("http://example.com/really-big-file.zip")
// have a ProgressBar get updated automatically with the percent
.progressBar(progressBar)
// and a ProgressDialog
.progressDialog(progressDialog)
// can also use a custom callback
.progress(new ProgressCallback() {@Override
   public void onProgress(long downloaded, long total) {
       System.out.println("" + downloaded + " / " + total);
   }
})
.write(new File("/sdcard/really-big-file.zip"))
.setCallback(new FutureCallback<File>() {
   @Override
    public void onCompleted(Exception e, File file) {
        // download done...
        // do stuff with the File or error
    }
});
```

#### Setting Headers

```
Ion.with(context)
.load("http://example.com/test.txt")
// set the header
.setHeader("foo", "bar")
.asString()
.setCallback(...)
```

#### Load an image into an ImageView

```
// This is the "long" way to do build an ImageView request... it allows you to set headers, etc.
Ion.with(context)
.load("http://example.com/image.png")
.withBitmap()
.intoImageView(imageView);

// but for brevity, use the ImageView specific builder...
Ion.with(imageView)
.load("http://example.com/image.png");
```

#### Futures

* 所有操作都返回一个自定义Future，允许您指定在完成时运行的回调。

```
public interface Future<T> extends Cancellable, java.util.concurrent.Future<T> {
    /**
     * Set a callback to be invoked when this Future completes.
     * @param callback
     * @return
     */
    public Future<T> setCallback(FutureCallback<T> callback);
}

Future<String> string = Ion.with(context)
.load("http://example.com/string.txt")
.asString();

Future<JsonObject> json = Ion.with(context)
.load("http://example.com/json.json")
.asJsonObject();

Future<File> file = Ion.with(context)
.load("http://example.com/file.zip")
.write(new File("/sdcard/file.zip"));

Future<Bitmap> bitmap = Ion.with(context)
.load("http://example.com/image.png")
.intoImageView(imageView);
```

#### Cancelling Requests

Futures can be cancelled by calling .cancel():

```
bitmap.cancel();
json.cancel();
```

#### Blocking on Requests

* 尽管您应该尽可能使用回调来处理请求，但阻塞请求也是可能的。所有的Future都有一个Future<T>.get()等待请求结果的方法，如有必要，可使之阻塞

```
JsonObject json = Ion.with(context)
.load("http://example.com/thing.json").asJsonObject().get();
```

#### Seamlessly use your own Java classes with [Gson])

```
public static class Tweet {
    public String id;
    public String text;
    public String photo;
}

public void getTweets() throws Exception {
    Ion.with(context)
    .load("http://example.com/api/tweets")
    .as(new TypeToken<List<Tweet>>(){})
    .setCallback(new FutureCallback<List<Tweet>>() {
       @Override
        public void onCompleted(Exception e, List<Tweet> tweets) {
          // chirp chirp
        }
    });
}
```

#### Logging

* 想知道为什么你的应用程序很慢吗？Ion允许您同时进行全局和请求级别的日志记录
* 要在全局范围内启用它：

```
Ion.getDefault(getContext()).configure().setLogging("MyLogs", Log.DEBUG);
```

* 或者仅仅让它在单个请求中生效：

```
Ion.with(context)
.load("http://example.com/thing.json")
.setLogging("MyLogs", Log.DEBUG)
.asJsonObject();
```

* log 实体 将会像这样：

```
D/MyLogs(23153): (0 ms) http://example.com/thing.json: Executing request.
D/MyLogs(23153): (106 ms) http://example.com/thing.json: Connecting socket
D/MyLogs(23153): (2985 ms) http://example.com/thing.json: Response is not cacheable
D/MyLogs(23153): (3003 ms) http://example.com/thing.json: Connection successful
```

#### Request Groups

* 默认情况下，Ion会自动将所有请求与所有其他请求放在一个组中
* 由该活动或服务创建的。使用cancelAll（Activity）调用，可以轻松取消所有仍挂起的请求

```
Future<JsonObject> json1 = Ion.with(activity, "http://example.com/test.json").asJsonObject();
Future<JsonObject> json2 = Ion.with(activity, "http://example.com/test2.json").asJsonObject();

// later... in activity.onStop
@Override
protected void onStop() {
    Ion.getDefault(activity).cancelAll(activity);
    super.onStop();
}
```

* Ion还允许您将请求标记为组，以便以后轻松取消该组中的请求：

```
Object jsonGroup = new Object();
Object imageGroup = new Object();

Future<JsonObject> json1 = Ion.with(activity)
.load("http://example.com/test.json")
// tag in a custom group
.group(jsonGroup)
.asJsonObject();

Future<JsonObject> json2 = Ion.with(activity)
.load("http://example.com/test2.json")
// use the same custom group as the other json request
.group(jsonGroup)
.asJsonObject();

Future<Bitmap> image1 = Ion.with(activity)
.load("http://example.com/test.png")
// for this image request, use a different group for images
.group(imageGroup)
.intoImageView(imageView1);

Future<Bitmap> image2 = Ion.with(activity)
.load("http://example.com/test2.png")
// same imageGroup as before
.group(imageGroup)
.intoImageView(imageView2);

// later... to cancel only image downloads:
Ion.getDefault(activity).cancelAll(imageGroup);
```

#### Proxy Servers (like Charles Proxy)

* 代理服务器设置可以在所有请求中启用，也可以在每个请求的基础上启用:

```
// proxy all requests
Ion.getDefault(context).configure().proxy("mycomputer", 8888);

// or... to proxy specific requests
Ion.with(context)
.load("http://example.com/proxied.html")
.proxy("mycomputer", 8888)
.getString();
```
* 在您的桌面计算机上使用Charles代理和请求代理将被证明是非常宝贵的调试

#### Viewing Received Headers

* Ion操作返回ResponseFuture，它通过response对象授予对响应属性的访问权。Response对象包含头和结果

```
Ion.with(getContext())
.load("http://example.com/test.txt")
.asString()
.withResponse()
.setCallback(new FutureCallback<Response<String>>() {
    @Override
    public void onCompleted(Exception e, Response<String> result) {
        // print the response code, ie, 200
        System.out.println(result.getHeaders().code());
        // print the String that was downloaded
        System.out.println(result.getResult());
    }
});
```