AndroidRetrofit2.0整合GoogleDriveAPI

最新推荐文章于 2022-06-02 13:33:55 发布
最新推荐文章于 2022-06-02 13:33:55 发布
阅读量429 收藏
点赞数
分类专栏： 学习笔记 文章标签： google drive android java
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/Double1010/article/details/110824761
版权

Android整合Google的文章太少了,写一篇记录一下自己所踩的坑
先放官方问文档:
GoogleDrive
其次就是得有个google账号，这部分略过
接下来是 Retrofit2.0实现Google Drive：
首先：okhttp不能少

    implementation 'com.squareup.retrofit2:retrofit:2.3.0'
    implementation 'com.squareup.retrofit2:converter-gson:2.3.0'
    implementation 'com.squareup.okhttp3:logging-interceptor:3.12.6'
    implementation group: 'com.google.code.gson', name: 'gson', version: '2.8.0'

自己根据官网整一下6个json基类吧，放上来太多了不美观分别是：UploadResult 、Token、User、DriveFiles、DriveFile、About

以下找不到的静态stirng基本就是Google申请的一些私人内容了我就不提供了

public class DriveHelper {

    private String TOKEN_KEY = "google_token";
    private String mAuthCode;
    private DriveApi mDriveApi;
    private String mAccessToken;
    private String mRefreshToken;

    public DriveHelper() {
        Retrofit retrofit = new Retrofit.Builder()
                .baseUrl(BASE_URL_API)
                .addConverterFactory(GsonConverterFactory.create())
                .build();
        mDriveApi = retrofit.create(DriveApi.class);
    }

    public void setAuthCode(String authCode) {
        try {
            mAuthCode = URLDecoder.decode(authCode, "UTF-8");
        } catch (UnsupportedEncodingException e) {
            e.printStackTrace();
        }

    }

    /**
     * 获取AccessToken
     *
     * @param callback 回调
     */
    public void getToken(final StateCallback callback) {
        Call<Token> call = mDriveApi.getToken(mAuthCode, CLIENT_ID,
                CLIENT_SECRET, REDIRECT_URI, "authorization_code");
        call.enqueue(new Callback<Token>() {
            @Override
            public void onResponse(Call<Token> call, Response<Token> response) {
                String message = DriveUtils.printResponse("getToken", response);
                if (message == null) {
                    Token token = response.body();
                    mAccessToken = token.getAccessToken();
                    mRefreshToken = token.getAccessToken();
                    SharePreferenceUtil.getInstance().commitString(TOKEN_KEY, mRefreshToken);
                    if (callback != null) {
                        callback.onSuccess();
                    }
                } else {
                    if (callback != null) {
                        callback.onFailure(message);
                    }
                }
            }

            @Override
            public void onFailure(Call<Token> call, Throwable t) {
                String message = DriveUtils.printFailure("getToken", t);
                if (callback != null) {
                    callback.onFailure(message);
                }
            }
        });
    }

    /**
     * 刷新AccessToken
     *
     * @param callback 回调
     */
    public void refreshToken(final StateCallback callback) {
        mRefreshToken = SharePreferenceUtil.getInstance().getString(TOKEN_KEY, "");
        if (mRefreshToken.equals("")) {
            if (callback != null) {
                callback.onFailure("");
            }
            return;
        }
        checkRefreshToken();
        Call<Token> call = mDriveApi.refreshToken(mRefreshToken, CLIENT_ID, CLIENT_SECRET, "refresh_token");
        call.enqueue(new Callback<Token>() {
            @Override
            public void onResponse(Call<Token> call, Response<Token> response) {
                String message = DriveUtils.printResponse("refreshToken", response);
                if (message == null) {
                    Token token = response.body();
                    mAccessToken = token.getAccessToken();
                    if (callback != null) {
                        callback.onSuccess();
                    }
                } else {
                    if (callback != null) {
                        callback.onFailure(message);
                    }
                }
            }

            @Override
            public void onFailure(Call<Token> call, Throwable t) {
                String message = DriveUtils.printFailure("refreshToken", t);
                if (callback != null) {
                    callback.onFailure(message);
                }
            }
        });
    }

    /**
     * 注销AccessToken
     *
     * @param callback 回调
     */
    public void revokeToken(final StateCallback callback) {
        SharePreferenceUtil.getInstance().commitString(TOKEN_KEY, "");
        checkAccessToken();
        Retrofit retrofit = new Retrofit.Builder().baseUrl(BASE_URL_ACCOUNT)
                .addConverterFactory(GsonConverterFactory.create()).build();
        Call<Void> call = retrofit.create(DriveApi.class).revokeToken(mAccessToken);
        call.enqueue(new Callback<Void>() {
            @Override
            public void onResponse(Call<Void> call, Response<Void> response) {
                String message = DriveUtils.printResponse("revokeToken", response);
                if (message == null) {
                    if (callback != null) {
                        callback.onSuccess();
                    }
                } else {
                    if (callback != null) {
                        callback.onFailure(message);
                    }
                }
            }

            @Override
            public void onFailure(Call<Void> call, Throwable t) {
                String message = DriveUtils.printFailure("revokeToken", t);
                if (callback != null) {
                    callback.onFailure(message);
                }
            }
        });
    }

    /**
     * 获取用户Google Drive账号信息
     *
     * @param callback 回调
     */
    public void getAbout(final StateCallback callback) {
        Call<About> call = mDriveApi.getAbout(getAuthToken(),
                "kind, user, maxUploadSize, appInstalled");
        call.enqueue(new Callback<About>() {
            @Override
            public void onResponse(Call<About> call, Response<About> response) {
                String message = DriveUtils.printResponse("getAbout", response);
                if (message == null) {
                    if (callback != null) {
                        callback.onSuccess();
                    }
                } else {
                    if (callback != null) {
                        callback.onFailure(message);
                    }
                }
            }

            @Override
            public void onFailure(Call<About> call, Throwable t) {
                String message = DriveUtils.printFailure("getAbout", t);
                if (callback != null) {
                    callback.onFailure(message);
                }
            }
        });
    }

    /**
     * 根据关键字搜索文件列表
     *
     * @param word     搜索关键字
     * @param callback 回调
     */
    public void searchFiles(String word, final ListCallback callback) {
        // 根据关键字搜索文件
        Call<DriveFiles> call = mDriveApi.getFiles(getAuthToken(),
                "modifiedTime", 1000, null, String.format("name contains '%s'", word));
        call.enqueue(new Callback<DriveFiles>() {
            @Override
            public void onResponse(Call<DriveFiles> call, Response<DriveFiles> response) {
                String message = DriveUtils.printResponse("searchFiles", response);
                if (message == null) {
                    if (callback != null) {
                        callback.onSuccess(response.body().getFiles());
                    }
                } else {
                    if (callback != null) {
                        callback.onFailure(message);
                    }
                }
            }

            @Override
            public void onFailure(Call<DriveFiles> call, Throwable t) {
                String message = DriveUtils.printFailure("searchFiles", t);
                if (callback != null) {
                    callback.onFailure(message);
                }
            }
        });
    }

    /**
     * 根据父目录ID获取子文件列表
     *
     * @param folderId 父目录ID
     * @param callback 回调
     */
    public void listFiles(String folderId, final ListCallback callback) {
        // 根据父目录的ID搜索文件
        Call<DriveFiles> call = mDriveApi.getFiles(getAuthToken(),
                "name", 1000, null, String.format("'%s' in parents", folderId));
        call.enqueue(new Callback<DriveFiles>() {
            @Override
            public void onResponse(Call<DriveFiles> call, Response<DriveFiles> response) {
                String message = DriveUtils.printResponse("listFiles", response);
                if (message == null) {
                    if (callback != null) {
                        callback.onSuccess(response.body().getFiles());
                    }
                } else {
                    if (callback != null) {
                        callback.onFailure(message);
                    }
                }
            }

            @Override
            public void onFailure(Call<DriveFiles> call, Throwable t) {
                String message = DriveUtils.printFailure("listFiles", t);
                if (callback != null) {
                    callback.onFailure(message);
                }
            }
        });
    }

    /**
     * 根据文件ID获取文件信息
     *
     * @param fileId   文件ID
     * @param callback 回调
     */
    public void getFile(String fileId, final StateCallback callback) {
        Call<DriveFile> call = mDriveApi.getFile(getAuthToken(), fileId);
        call.enqueue(new Callback<DriveFile>() {
            @Override
            public void onResponse(Call<DriveFile> call, Response<DriveFile> response) {
                String message = DriveUtils.printResponse("getFile", response);
                if (message == null) {
                    if (callback != null) {
                        callback.onSuccess();
                    }
                } else {
                    if (callback != null) {
                        callback.onFailure(message);
                    }
                }
            }

            @Override
            public void onFailure(Call<DriveFile> call, Throwable t) {
                String message = DriveUtils.printFailure("getFile", t);
                if (callback != null) {
                    callback.onFailure(message);
                }
            }
        });
    }

    /**
     * 从Google Drive下载文件
     *
     * @param fileId   需要下载的文件ID
     * @param dstFile  下载文件到本地的路径
     * @param callback 回调
     */
    public void downloadFile(String fileId, final File dstFile, final StateCallback callback) {
        Call<ResponseBody> call = mDriveApi.downloadFile(getAuthToken(), fileId);
        call.enqueue(new Callback<ResponseBody>() {
            @Override
            public void onResponse(Call<ResponseBody> call, Response<ResponseBody> response) {
                String message = DriveUtils.printResponse("downloadFile", response);
                if (message == null) {
                    BufferedInputStream bis = new BufferedInputStream(response.body().byteStream());
                    BufferedOutputStream bos = null;
                    try {
                        bos = new BufferedOutputStream(new FileOutputStream(dstFile));
                        int length;
                        byte[] buffer = new byte[1024];
                        while ((length = bis.read(buffer)) != -1) {
                            bos.write(buffer, 0, length);
                        }
                        bos.flush();
                        if (callback != null) {
                            callback.onSuccess();
                        }
                    } catch (IOException e) {
                        e.printStackTrace();
                        if (callback != null) {
                            callback.onFailure(Log.getStackTraceString(e));
                        }
                    } finally {
                        try {
                            bis.close();
                        } catch (IOException e) {
                            e.printStackTrace();
                        }
                        try {
                            if (bos != null)
                                bos.close();
                        } catch (IOException e) {
                            e.printStackTrace();
                        }
                    }
                } else {
                    if (callback != null) {
                        callback.onFailure(message);
                    }
                }
            }

            @Override
            public void onFailure(Call<ResponseBody> call, Throwable t) {
                String message = DriveUtils.printFailure("downloadFile", t);
                if (callback != null) {
                    callback.onFailure(message);
                }
            }
        });
    }

    public void uploadFile(File srcFile, String folderId, StateCallback callback) {
        if (mAccessToken != null)
            uploadFile(srcFile, srcFile.getName(), folderId, callback);
        else {
            ToastUtils.show(R.string.network_storage_do_not_login, Utils.INSTANCE.getApp().getApplicationContext());
        }
    }

    /**
     * 上传文件到指定目录
     *
     * @param srcFile  本地需要上传的文件
     * @param title    上传文件名称
     * @param folderId 上传文件父目录ID
     * @param callback 回调
     */
    public void uploadFile(File srcFile, String title, final String folderId, final StateCallback callback) {
        MediaType contentType = MediaType.parse("application/json; charset=UTF-8");
        String content = "{\"name\": \"" + title + "\"}";
        MultipartBody.Part metaPart = MultipartBody.Part.create(RequestBody.create(contentType, content));
        String mimeType = CommonUtils.getMimeType(srcFile);
        MultipartBody.Part dataPart = MultipartBody.Part.create(RequestBody.create(MediaType.parse(mimeType), srcFile));

        Call<UploadResult> call = mDriveApi.uploadFile(getAuthToken(), metaPart, dataPart);
        call.enqueue(new Callback<UploadResult>() {
            @Override
            public void onResponse(Call<UploadResult> call, Response<UploadResult> response) {
                String message = DriveUtils.printResponse("uploadFile", response);
                if (message == null) {
                    moveFile(response.body().getId(), folderId, new StateCallback() {
                        @Override
                        public void onSuccess() {
                            if (callback != null) {
                                callback.onSuccess();
                            }
                        }

                        @Override
                        public void onFailure(String msg) {
                            if (callback != null) {
                                callback.onFailure(msg);
                            }
                        }
                    });
                } else {
                    if (callback != null) {
                        callback.onFailure(message);
                    }
                }
            }

            @Override
            public void onFailure(Call<UploadResult> call, Throwable t) {
                String message = DriveUtils.printFailure("uploadFile", t);
                if (callback != null) {
                    callback.onFailure(message);
                }
            }
        });
    }

    /**
     * 从根目录移动文件
     *
     * @param fileId      需要移动的文件ID
     * @param dstFolderId 目标目录ID
     * @param callback    回调
     */
    public void moveFile(String fileId, String dstFolderId, StateCallback callback) {
        moveFile(fileId, dstFolderId, ROOT_DRIVE_ID, callback);
    }

    /**
     * 移动文件
     *
     * @param fileId      需要移动的文件ID
     * @param dstFolderId 目标目录ID
     * @param srcFolderId 源目录ID
     * @param callback    回调
     */
    public void moveFile(String fileId, String dstFolderId, String srcFolderId, final StateCallback callback) {
        Call<DriveFile> call = mDriveApi.moveFile(getAuthToken(), fileId, dstFolderId, srcFolderId);
        call.enqueue(new Callback<DriveFile>() {
            @Override
            public void onResponse(Call<DriveFile> call, Response<DriveFile> response) {
                String message = DriveUtils.printResponse("moveFile", response);
                if (message == null) {
                    if (callback != null) {
                        callback.onSuccess();
                    }
                } else {
                    if (callback != null) {
                        callback.onFailure(message);
                    }
                }
            }

            @Override
            public void onFailure(Call<DriveFile> call, Throwable t) {
                String message = DriveUtils.printFailure("moveFile", t);
                if (callback != null) {
                    callback.onFailure(message);
                }
            }
        });
    }

    /**
     * 复制
     */
    public void copyFile(String fileId, final StateCallback callback) {
        Call<DriveFile> call = mDriveApi.copyFile(getAuthToken(), fileId);
        call.enqueue(new Callback<DriveFile>() {
            @Override
            public void onResponse(Call<DriveFile> call, Response<DriveFile> response) {
                String message = DriveUtils.printResponse("copyFile", response);
                if (message == null) {
                    if (callback != null) {
                        callback.onSuccess();
                    }
                } else {
                    if (callback != null) {
                        callback.onFailure(message);
                    }
                }
            }

            @Override
            public void onFailure(Call<DriveFile> call, Throwable t) {
                String message = DriveUtils.printFailure("copyFile", t);
                if (callback != null) {
                    callback.onFailure(message);
                }
            }
        });
    }

    /**
     * 删除文件
     *
     * @param fileId   需要删除的文件ID
     * @param callback 回调
     */
    public void deleteFile(String fileId, final StateCallback callback) {
        Call<Void> call = mDriveApi.deleteFile(getAuthToken(), fileId);
        call.enqueue(new Callback<Void>() {
            @Override
            public void onResponse(Call<Void> call, Response<Void> response) {
                String message = DriveUtils.printResponse("deleteFile", response);
                if (message == null) {
                    if (callback != null) {
                        callback.onSuccess();
                    }
                } else {
                    if (callback != null) {
                        callback.onFailure(message);
                    }
                }
            }

            @Override
            public void onFailure(Call<Void> call, Throwable t) {
                String message = DriveUtils.printFailure("deleteFile", t);
                if (callback != null) {
                    callback.onFailure(message);
                }
            }
        });
    }

    private String getAuthToken() {
        checkAccessToken();
        return String.format(AUTH_TOKEN, mAccessToken);
    }

    private void checkRefreshToken() {
        if (mRefreshToken == null) {
            throw new IllegalStateException("Refresh token is null!");
        }
    }

    private void checkAccessToken() {
        if (mAccessToken == null) {
            throw new IllegalStateException("Access token is null!");
        }
    }
}

DriveApi 类:

public interface DriveApi {

    /**
     * https://developers.google.com/identity/protocols/OAuth2InstalledApp
     */
    @POST("/oauth2/v4/token")
    @FormUrlEncoded
    Call<Token> getToken(
            @Field("code") String code,
            @Field("client_id") String clientId,
            @Field("client_secret") String clientSecret,
            @Field("redirect_uri") String redirectUri,
            @Field("grant_type") String grantType
    );

    /**
     * https://developers.google.com/identity/protocols/OAuth2InstalledApp
     */
    @POST("/oauth2/v4/token")
    @FormUrlEncoded
    Call<Token> refreshToken(
            @Field("refresh_token") String refreshToken,
            @Field("client_id") String clientId,
            @Field("client_secret") String clientSecret,
            @Field("grant_type") String grantType
    );

    /**
     * https://accounts.google.com/o/oauth2/revoke?token={token}
     */
    @GET("/o/oauth2/revoke")
    Call<Void> revokeToken(
            @Query("token") String token
    );

    /**
     * https://developers.google.com/drive/v3/reference/about
     */
    @GET("/drive/v3/about")
    Call<About> getAbout(
            @Header("Authorization") String authToken,
            @Query("fields") String fields
    );

    /**
     * https://developers.google.com/drive/v3/reference/files/list
     */
    @GET("/drive/v3/files")
    Call<DriveFiles> getFiles(
            @Header("Authorization") String authToken,
            @Query("orderBy") String orderBy,
            @Query("pageSize") int pageSize,
            @Query("pageToken") String pageToken,
            @Query("q") String q
    );

    /**
     * https://developers.google.com/drive/v3/reference/files/get
     */
    @GET("/drive/v3/files/fileId")
    Call<DriveFile> getFile(
            @Header("Authorization") String authToken,
            @Query("fileId") String driveId
    );

    /**
     * https://developers.google.com/drive/v3/web/manage-downloads
     */
    @GET("/drive/v3/files/{fileId}?alt=media")
    Call<ResponseBody> downloadFile(
            @Header("Authorization") String authToken,
            @Path(value = "fileId") String fileId
    );

    /**
     * https://developers.google.com/drive/v3/web/multipart-upload
     */
    @POST("/upload/drive/v3/files?uploadType=multipart")
    @Multipart
    Call<UploadResult> uploadFile(
            @Header("Authorization") String authToken,
            @Part MultipartBody.Part metaPart,
            @Part MultipartBody.Part dataPart
    );

    /**
     * https://developers.google.com/drive/v3/reference/files/update
     */
    @PATCH("/drive/v3/files/{fileId}")
    Call<DriveFile> moveFile(
            @Header("Authorization") String authToken,
            @Path(value = "fileId") String fileId,
            @Query("addParents") String addParents,
            @Query("removeParents") String removeParents
    );

    /**
     * https://developers.google.com/drive/v3/reference/files/delete
     */
    @DELETE("/drive/v3/files/{fileId}")
    Call<Void> deleteFile(
            @Header("Authorization") String authToken,
            @Path(value = "fileId") String fileId
    );


    /**
     * https://www.googleapis.com/drive/v3/files/fileId/copy
     */
    @POST("/drive/v3/files/{fileId}/copy")
    Call<DriveFile> copyFile(
            @Header("Authorization") String authToken,
            @Path(value = "fileId") String fileId
    );

}

public final class DriveUtils {

    private DriveUtils() {

    }

    public static String getAuthUri() {
        return String.format(Constants.AUTH_URL, Constants.CLIENT_ID);
    }

    public static String printResponse(String msg, Response<?> response) {
        CommonUtils.D(msg, "onResponse", response.toString());
        if (response.isSuccessful()) {
            CommonUtils.E(msg, "success", response.body());
            return null;
        } else {
            String errorMessage = null;
            try {
                errorMessage = response.errorBody().string();
            } catch (IOException e) {
                e.printStackTrace();
            }
            CommonUtils.W(msg, "failure", errorMessage);
            return msg + " failed: " + errorMessage;
        }
    }

    public static String printFailure(String msg, Throwable t) {
        String message = Log.getStackTraceString(t);
        CommonUtils.W(msg, "onFailure", message);
        return msg + " failed: " + message;
    }
}

public final class CommonUtils {

    private static final String TAG = "StephenLee";
    private static final String DIVIDER = " - ";
    private static boolean isDebug = true;

    private CommonUtils() {

    }

    public static String getExtension(File file) {
        return getExtension(file.getName());
    }

    public static String getExtension(String fileName) {
        String lowerName = fileName.toLowerCase();
        if (!lowerName.contains("."))
            return "";
        return lowerName.substring(lowerName.lastIndexOf(".") + 1);
    }

    public static String getMimeType(File file) {
        MimeTypeMap map = MimeTypeMap.getSingleton();
        String mimeType = map.getMimeTypeFromExtension(getExtension(file));
        if (TextUtils.isEmpty(mimeType))
            return "*/*";
        return mimeType;
    }

    public static void setDebug(boolean isDebug) {
        CommonUtils.isDebug = isDebug;
    }

    public static void V(Object... args) {
        println(Log.VERBOSE, args);
    }

    public static void D(Object... args) {
        println(Log.DEBUG, args);
    }

    public static void I(Object... args) {
        println(Log.INFO, args);
    }

    public static void W(Object... args) {
        println(Log.WARN, args);
    }

    public static void E(Object... args) {
        println(Log.ERROR, args);
    }

    private static void println(int priority, Object... args) {
        if (args == null || args.length == 0) {
            println(priority, Arrays.toString(args));
            return;
        }
        StringBuilder sb = new StringBuilder();
        sb.append(args[0]);
        for (int i = 1; i < args.length; i++) {
            sb.append(DIVIDER).append(args[i]);
        }
        println(priority, sb.toString());
    }

    private static void println(int priority, String msg) {
        if (isDebug) {
            Log.println(priority, TAG, msg);
        }
    }
}

网上demo应该也有，基本只有上传下载这两个功能
目前API可行的功能:上传(不可上传文件夹)/下载/删除/复制/剪切功能
无:创建文件夹/重命名

googledrive大型文件上传

小张同志正在划水
关注
  • 0
    点赞
  • 踩
  • 0
    收藏
    觉得还不错? 一键收藏
  • 1
    评论
专栏目录
Google升级Drive SDK，支持Android/iOS应用集成
tanghongchang123的博客
05-18 1979
最近项目的需求有一个要实现Google Drive 云存储的功能，我现在网上找了很久啊，终于在Google 找到一个Demo模块啊，进行集成，集成到了最后出现了一个Bug,就是您的手机没有安装Google Play服务，因此无法运行，这个是很正常的啊，你要一台手机有Google Play服务的啊，因为现在国内的手机基本上都把Google Play的服务给去掉了，如果真要有的话，我建议用三星手机进行
fota说明情况使用
01-16
fota使用说明情况，请下载查阅，请多多支持
YoC RTOS 实战：FOTA系统升级
DOT小文哥的博客
06-02 2234
建议在操作前先阅读以下技术文章： Lichee D1 dock 开发板用户指南 Lichee D1 dock 开发板快速上手教程本文介绍如何在D1开发板上进行FOTA升级。FOTA 是 Firmware Over the Air 的缩写，即固件空中升级，最常见的就是手机固件的升级。固件的定义范围比较模糊，windows操作系统升级、手机升级、嵌入式系统、单片机控制程序等都的远程升级可以笼统地称为FOTA。用这种方式，设备厂商可以更加快速地进行系统软件的迭代；能够更加快速地向市场推出具有新功能的设备并以此提高
FOTA升级简介
热门推荐
carlos博客
06-30 1万+
1、FOTA升级简介 FOTA（Firmware Over-The-Air）移动终端的空中下载软件升级，指通过云端升级技术，为具有连网功能的设备提供固件升级服务。在物联网通讯模块领域，FOTA主要应用于更新升级芯片内部软件模块，进行功能优化和需求定制升级等功能。 FOTA（Over-the-Air Technology）升级有两种类型，分别是：Increment OTA（增量/差分）和Full OTA（整包），每一种类型都有对应的用途和优势。 本文采用的是Increment OTA（增量/差分）升级方式。使
FOTA升级差分包编译服务器搭建
chenwr2018的博客
06-14 2349
奈何公司测试组电脑没有Linux系统，每次测试FOTA升级用的差分包都需要找我来制作，实在麻烦。本想搞个QT界面弄得专业点，后面有时间再去搞吧，现在打算先临时写一个应急。 一、Ubuntu端先搭建FTP服务器 参考之前搭建的记录 Ubuntu14.04搭建FTP服务器记录 - chenwr2018的博客 - CSDN博客 https://blog.csdn.net/chenwr2018/art...
EC20开发文档以及开发工具.zip
09-02
包含EC20的开发文档以及专用串口开发工具，内容完善。
华为云IoT智慧物流案例10 | 广和通L610模组FOTA升级（服务端FileZilla Server客户端FileZilla）
WGP CGR实柏的博客
08-05 580
华为云IoT智慧物流案例10 | 广和通L610模组FOTA升级（服务端FileZilla Server客户端FileZilla）第一章 使用FileZilla Server搭建FTP服务器第二章 通过FileZilla客户端访问FTP服务器第三章 L610进行FOTA升级固件 FOTA升级作用：在官方更新新固件后，模组设备无需寄回给官方，而是通过远程FTP/HTTP进行OTA升级固件，以更新新固件版本，从而达到更新设备的功能/BUG修复。 本次我采用FPT的方式来升级L610的固件,FPT可以选择购买华为
接入Google drive的开发过程
weixin_41820878的博客
07-14 2971
接入Google drive的开发过程开始关键词参考资料步骤1步骤2 开始 一开始是在使用Android studio编译的apk里面接入Google drive，后来由于公司在系统源码环境编译的apk也需要接入apk，对于两次开发做一次记录。 关键词 **Google drive， Android studio， Android系统源码，aar** 参考资料 Google driver 开发API ：https://developers.google.com/drive/ 说明文档：https:/
Android版Google Drive API
专业的开发者“讨论”
06-03 1296
有许多上传图片和文件的方法。 另外，有很多地方可&#2019...
部署一个http服务
Tyfly的博客
11-13 1716
部署一个http服务 1.配置yum源 在 /etc/yum.repo.d/目录下创建rhel.repo文件并添加yum源 [root@a ~]# vi /etc/yum.repos.d/rhel.repo 文件内容如下： [rhel] name=rhel 7.7 baseurl=http://10.24.69.0/rhel7.7/ enabled=1 gpgcheck=1 gpgkey=http://10.24.69.0/rhel7.7/RPM-GPG-KEY-redhat-release 2.安装h
RxJava整合Retrofit2.0网络框架
12-07
RxJava整合Retrofit2.0网络框架，将城市天气查询作为一个使用案例
Android使用Retrofit2.0技术仿微信发说说
08-31
主要介绍了Android使用Retrofit2.0技术仿微信发说说，实现拍照，选图库，多图案上传功能，具有一定的参考价值，感兴趣的小伙伴们可以参考一下
Retrofit2.0 Demo
04-23
这是一个基于Retrofit2.0 + Okhttp +Gson的一个请求网络的小案例
Android Retrofit 2.0框架上传图片解决方案
09-02
主要介绍了Android Retrofit 2.0框架上传一张与多张图片解决方案，感兴趣的小伙伴们可以参考一下
Android中Retrofit2.0的使用Demo
04-02
这个Demo实现了使用Retrofit2.0网络请求框架请求数据，使用Gson解析数据,希望对大家有用
全志OTA远程升级服务器搭建注意事项
橙子和小果的博客
07-27 3531
目前是按照文档《OTA服务器端配置.pdf》验证OK有以下注意事项：资料下载地址：https://download.csdn.net/download/tsb151/10277863开发坏境：window7 32bit运行系统：rhel-server-6.2-i386-dvd.iso运行环境：VMware 10PS:在Redhat Enterprise Linux AS 6.2 系统上进行是Ok,...
android开发接入Google api登录功能，获取sha1，以及生成debug的sha1
ZJQ的博客
09-08 1697
goole开发文档说明：https://developers.google.com/drive/api/v3/about-auth 最后使用google浏览器，右键进行翻译。 关于授权 您的应用程序发送给Drive API的每个请求都必须包含授权令牌。该令牌还可识别您的Google应用程序。 关于授权协议 您的应用程序必须使用OAuth 2.0来授权请求​​。不支持其他授权协议。如果您的...
关于自有系统集成google原生登录的小结
夏季版
03-18 567
最近产品在规划将我们android端的apk集成google的原生登录，就将自己的预研的成果分享下： 参考的google集成登录文档官网地址为：https://developers.google.com/identity/sign-in/android/start https://developers.google.com/identity/sign-in/android/offline-acce...
8910DM：FOTA 升级指导
Jimmy的blog
12-24 887
#1.OpenCPU FOTA简介 使用此种方式升级，需要先将升级包放到设备上，可以通过很多方式，如http、ftp、或UART等。调用升级API，设备自行检测升级包，验证通过后进行版本升级。升级过程支持断电异常处理，不会导致启动失败情况发生。 升级包有两种类型：整包，差分包 整包只使用新版本pac包制作，分为：系统固件，APP 差分包使用新、旧pac包制作，分为；系统固件，APP，整机（系统固件与应用可以统一升级，避免单独升级可能出现的不兼容问题） #2.工具简介 您需要获取支持linux和 window
Android用retrofit上传图片,Retrofit2.0 实现图文（参数+图片）上传方法总结
最新发布
05-25
在 Android 中使用 Retrofit 上传图片可以通过 `@Multipart` 和 `@Part` 注解实现。以下是 Retrofit 2.0 实现图文上传的方法总结： 1. 添加依赖库 在项目的 `build.gradle` 文件中添加以下依赖库： ```groovy ...

“相关推荐”对你有帮助么？

  • 非常没帮助
  • 没帮助
  • 一般
  • 有帮助
  • 非常有帮助
提交
评论 1
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值