// Upload_Domain1, Upload_Domain2 为服务下发的上传域名
FixedZone fixedZone = new FixedZone(new String[]{"Upload_Domain1", "Upload_Domain2"});
Configuration config = new Configuration.Builder()
     .zone(fixedZone)
     .build();
UploadManager manager = new UploadManager(config);

// 指定上传区域为 华东-浙江
FixedZone zone = FixedZone.createWithRegionId("z0");

// Upload_Domain1, Upload_Domain2 为服务下发的上传域名
FixedZone zone = new FixedZone(new String[]{"Upload_Domain1", "Upload_Domain2"});

// 不指定 uc 域名，使用七牛公有云默认域名
AutoZone zone = new AutoZone();

// 指定 uc 域名，公有云无需指定
AutoZone zone = new AutoZone();
zone.setUcServers(new String[]{"UCHost0", "UCHost1"});

import com.qiniu.android.common.FixedZone;
import com.qiniu.android.http.ResponseInfo;
import com.qiniu.android.storage.Configuration;
import com.qiniu.android.storage.FileRecorder;
import com.qiniu.android.storage.KeyGenerator;
import com.qiniu.android.storage.Recorder;
import com.qiniu.android.storage.UpCancellationSignal;
import com.qiniu.android.storage.UpCompletionHandler;
import com.qiniu.android.storage.UpProgressHandler;
import com.qiniu.android.storage.UploadManager;
import com.qiniu.android.storage.UploadOptions;
import com.qiniu.android.utils.Utils;

Recorder recorder = null;
try {
    recorder = new FileRecorder(Utils.sdkDirectory() + "/recorder");
} catch (IOException e) {
    e.printStackTrace();
}

// uploadHosts 建议通过服务方式下发，
String[] uploadHosts = new String[]{"Host0", "Host1"};
FixedZone zone = new FixedZone(uploadHosts);
Configuration configuration = new Configuration.Builder()
        .zone(zone)                         // 配置上传区域
        .putThreshold(4 * 1024 * 1024) // 分片上传阈值：4MB，大于 4MB 采用分片上传，小于 4MB 采用表单上传
        .useConcurrentResumeUpload(true)   // 开启分片上传
        .recorder(recorder)  // 文件分片上传时断点续传信息保存，表单上传此配置无效
        .resumeUploadVersion(Configuration.RESUME_UPLOAD_VERSION_V2) // 使用分片 V2
        .build();
UploadManager uploadManager = new UploadManager(configuration);

UploadOptions options = new UploadOptions(null, null, true,
        new UpProgressHandler() {
            @Override
            public void progress(String key, double percent) {
                // 上传进度
            }
        }, new UpCancellationSignal() {
    @Override
    public boolean isCancelled() {
        // 当需要取消时，此处返回 true，SDK 内部会多次检查返回值，当返回值为 true 时会取消上传操作
        return false;
    }
});

String filePath = "";    // 文件路径
String key = "";         // 文件 key
String uploadToken = ""; // 上传的 Token
uploadManager.put(filePath, key, uploadToken, new UpCompletionHandler() {
    @Override
    public void complete(String key, ResponseInfo info, JSONObject response) {
        if (info != null && info.isOK()) {
            // 上传成功
        } else {
            // 上传失败
        }
    }
}, options);

// 1. 在七牛云存储控制台修改 Bucket 配置，域名管理 -> 开启传输加速（SDK 开启使用加速域名上传的功能仅仅是 SDK 支持
//    使用加速域名，所以要想使用传输加速，七牛云服务端需开启此功能）
// 
// 2. SDK 配置 
// 方式一：使用 FixZone 配置
// Upload_Domain1 和 Upload_Domain2 为加速域名，可以参考七牛云存储控制台域名管理页面，建议通过用户服务下发，不要硬编码
Zone zone = new FixedZone(new String[]{"Upload_Domain1", "Upload_Domain2"});
Configuration configuration = new Configuration.Builder()
                .zone(zone)    // 区域必须使用 AutoZone，默认是 AutoZone，所以 zone 也可以不配置
                .build();

// 方式二：使用 AutoZone（v8.8.0 开始支持）
Configuration configuration = new Configuration.Builder()
                .accelerateUploading(true) // 开启传输加速，此参数仅对使用 QNAutoZone 时有效
                .zone(new AutoZone())      // 默认是 AutoZone，所以 zone 也可以不配置
                .build();

// 移除 qiniu-android-sdk 依赖 : implementation 'com.qiniu:qiniu-android-sdk:x.x.+' 
implementation 'com.qiniu:qiniu-android-curl-plugin:1.0.0'

import com.qiniu.client.curl.CurlClient;
import com.qiniu.android.storage.GlobalConfiguration;
import com.qiniu.android.storage.Configuration;
import com.qiniu.android.storage.UploadManager;

// 开启 HTTP/3
GlobalConfiguration.getInstance().enableHttp3 = true;

// @param caPath: SSL 证书本地路径；如果想自定义 CA 可设置此选项，此处为 CA 文件的本地路径。
// 				  如果未定义（caPath 配置 null）则使用 SDK 内部提供的 CA 证书，证书来源：https://curl.se/ca/cacert.pem
CurlClient client = new CurlClient(caPath);
Configuration config = new Configuration.Builder()
                .requestClient(client) // 指定 HTTP/3 Client
                .build();
UploadManager manager = new UploadManager(config);

implementation 'com.qiniu:happy-dns:2.0.1'

import com.qiniu.android.dns.DnsManager;
import com.qiniu.android.dns.Domain;
import com.qiniu.android.dns.IResolver;
import com.qiniu.android.dns.NetworkInfo;
import com.qiniu.android.dns.Record;
import com.qiniu.android.dns.dns.DnsUdpResolver;
import com.qiniu.android.dns.dns.DohResolver;
import com.qiniu.android.http.dns.Dns;
import com.qiniu.android.http.dns.IDnsNetworkAddress;

import java.io.IOException;
import java.net.UnknownHostException;
import java.util.ArrayList;
import java.util.List;

class CustomDns {

    public static Dns buildDefaultDns() {
//         可添加修改 多个 IResolver
//         适当调整不同 IResolver 的加入顺序，比如:223.5.5.5，119.29.29.29，114.114.114.114，8.8.8.8 等
        IResolver[] resolvers = new IResolver[2];
        // 自定义 DNS 服务器地址: UDP
        resolvers[0] = new DnsUdpResolver("8.8.8.8");
        // 自定义 DNS 服务器地址：Doh
        resolvers[1] = new DohResolver("https://dns.alidns.com/dns-query");

        final DnsManager dnsManager = new DnsManager(NetworkInfo.normal, resolvers);
        Dns dns = new Dns() {
            // 若抛出异常 Exception ，sdk 会使用 okhttp 组件默认 dns 解析结果
            @Override
            public List<IDnsNetworkAddress> lookup(String hostname) throws UnknownHostException {
                Domain domain = new Domain(hostname);
                List<IDnsNetworkAddress> addressList = null;
                try {
                    Record[] records = dnsManager.queryRecords(domain);
                    if (records != null && records.length > 0) {
                        addressList = new ArrayList<>();
                        for (Record record : records) {
                            String source = "customized";
                            DemoDnsNetworkAddress address = new DemoDnsNetworkAddress(hostname, record.value, (long) record.ttl, source, record.timeStamp);
                            addressList.add(address);
                        }
                    }
                } catch (IOException ignored) {
                }
                return addressList;
            }
        };
        return dns;
    }

    public static class DemoDnsNetworkAddress implements IDnsNetworkAddress {
        private final String hostValue;
        private final String ipValue;
        private final Long ttlValue;
        private final String sourceValue;
        private final Long timestampValue;

        DemoDnsNetworkAddress(String hostValue,
                              String ipValue,
                              Long ttlValue,
                              String sourceValue,
                              Long timestampValue) {
            this.hostValue = hostValue;
            this.ipValue = ipValue;
            this.ttlValue = ttlValue;
            this.sourceValue = sourceValue;
            this.timestampValue = timestampValue;
        }

        @Override
        public String getHostValue() {
            return hostValue;
        }

        @Override
        public String getIpValue() {
            return ipValue;
        }

        @Override
        public Long getTtlValue() {
            return ttlValue;
        }

        @Override
        public String getSourceValue() {
            return sourceValue;
        }

        @Override
        public Long getTimestampValue() {
            return timestampValue;
        }
    }
}

// 在 UploadManager 初始化之前配置    
GlobalConfiguration.getInstance().dns = CustomDns.buildDefaultDns();
uploadManager = new UploadManager();

// 自定义请求 client，需要自行实现
IRequestClient client = null;

// 定义分片上传时，断点续传信息保存的 Recorder
Recorder recorder = null;
try {
    recorder = new FileRecorder(Utils.sdkDirectory() + "/recorder");
} catch (IOException e) {
    e.printStackTrace();
}

// 断点续传信息保存时使用的 key 的生成器，根据 key 可以获取相应文件的上传信息
// 需要确保每个文件的 key 是唯一的，下面为默认值
// 可以自定义，也可以不配置（keyGenerator 参数可以不传）
KeyGenerator keyGenerator = new KeyGenerator() {
    @Override
    public String gen(String key, File file) {
        return key + "_._" + new StringBuffer(file.getAbsolutePath()).reverse();
    }
    @Override
    public String gen(String key, String sourceId) {
        if (sourceId == null) {
            sourceId = "";
        }
        return key + "_._" + sourceId;
    }
};

// 定义代理
ProxyConfiguration proxy = new ProxyConfiguration("192.168.1.1", 8888);
Configuration configuration = new Configuration.Builder()
        .requestClient(client)  // 自定义请求 client，内部所有请求都会走此 client
        .zone(new AutoZone())              // 配置上传区域，使用 AutoZone
        .recorder(recorder, keyGenerator)  // 文件分片上传时断点续传信息保存，表单上传此配置无效
        .proxy(proxy)
        .useHttps(false)
        .chunkSize(4*1024*1024) // 文件采用分片上传时，分片大小为 4MB
        .putThreshold(4 * 1024 * 1024) // 分片上传阈值：4MB，大于 4MB 采用分片上传，小于 4MB 采用表单上传
        .connectTimeout(10) // 请求连接超时 10s
        .writeTimeout(30) // 请求写超时 30s
        .responseTimeout(10) // 请求响应超时 10s
        .retryMax(1) // 单个域名/IP请求失败后最大重试次数为 1 次
        .retryInterval(500) // 重试时间间隔
        .allowBackupHost(true) // 是否使用备用域名进行重试
        .urlConverter(new UrlConverter() {
            @Override
            public String convert(String url) {
                // 公有云不可配置
                return url;
            }
        })
        .useConcurrentResumeUpload(true)  // 开启并发分片上传
        .concurrentTaskCount(3)           // 使用并发分片上传时，一个文件并发上传的分片个数
        .resumeUploadVersion(Configuration.RESUME_UPLOAD_VERSION_V2) // 使用分片 V2
        .build();

// 用于服务器上传回调通知的自定义参数，参数的key必须以x: 开头  eg: x:foo
Map<String, String> params = new HashMap<>();
// 用于设置meta数据，参数的key必须以x-qn-meta- 开头  eg: x-qn-meta-key
Map<String, String> metaDataParam = new HashMap<>();
// 指定文件 mime type
String mimeType = "";
UploadOptions options = new UploadOptions(params, null, mimeType, true,
        new UpProgressHandler() {
            @Override
            public void progress(String key, double percent) {
                // 上传进度
            }
        }, new UpCancellationSignal() {
    @Override
    public boolean isCancelled() {
        // 当需要取消时，此处返回 true，SDK 内部会多次检查返回值，当返回值为 true 时会取消上传操作
        return false;
    }
}, null);

// 关闭 DNS 预解析
GlobalConfiguration.getInstance().isDnsOpen = false;
// 关闭网络状态检测，当因网络异常而失败时，会检测网络状态，进而根据情况调整重试逻辑
GlobalConfiguration.getInstance().connectCheckEnable = false;