记录AndroidStudio搭建离线环境_内网安装android studio

最近要做内网离线开发，记录一下离线AndroidStudio配置

联网安装就不赘述了，这里把联网配置好的东西都拷贝到离线电脑上，然后逐步配置

1.C盘下.gradle文件夹整体打压缩包

2.sdk目录除去system-images文件夹(太大了，没什么用)，其他所有文件夹打压缩包

3.androidstudio安装包，我下载的是3.4.1，放上官方地址

https://developer.android.google.cn/studio/archive.html#android-studio-2-3-2?utm_source=androiddevtools&utm_medium=website

4.下载官方提供的离线包，地址还是上边的官网地址

这四步拷贝到离线电脑，接下来开始安装

1.安装Androidstudio

2.将.gradle放到C盘user当前用户目录下

3.sdk放到自己想放的位置

4.androidstudio设置离线工作模式 setting -> build.execution,deployment -> gradle , 勾选offline work,或者再右侧gradle选择离线按钮

5.设置离线gradle，上边位置输入gradle路径

6.将下载的离线库解压到 C:user/当前用户/.android/manual-offline-m2,最后边文件夹应该没有，手动创建，这里需注意，最终依赖的路径应该是C:user/当前用户/.android/manual-offline-m2/gmaven_stable/各种依赖库...，解压压缩包的时候可能会有一个offline-gmaven_stable记得把这一层删掉

7.创建offline.gradle文件，目录为

文件内容如下

def reposDir = new File(System.properties['user.home'], ".android/manual-offline-m2")
def repos = new ArrayList()
reposDir.eachDir {repos.add(it) }
repos.sort()
 
allprojects {
  buildscript {
    repositories {
      for (repo in repos) {
        maven {
          name = "injected_offline_${repo.name}"
          url = repo.toURI().toURL()
        }
      }
    }
  }
  repositories {
    for (repo in repos) {
      maven {
        name = "injected_offline_${repo.name}"
        url = repo.toURI().toURL()
      }
    }
  }
}

8.到这里新建的android项目应该没问题了，下边给出如何添加其他依赖库的方式

这个目录下放的是依赖缓存，把联网电脑这里的依赖包拷贝到离线电脑的官方依赖库，基本都有了，如果需要添加新的，下载jar包按照官方依赖库的文件层级目录放进去就行，这里说一下这里的jar包层级目录跟官方依赖库的层级是不一样的，现在要做的就是先把这里的层级目录改变然后拷贝到官方依赖库就可以了

将这个文件夹先拷贝到一个新建文件夹里方便操作，以防修改我们本来的gradle，我用的位置是D:\\test\\files-2.1，给出一个工具类，运行一下就行了

import java.io.File;
import java.io.FileInputStream;
import java.io.FileNotFoundException;
import java.io.FileOutputStream;
import java.io.IOException;
import java.util.ArrayList;
import java.util.LinkedList;
 
import java.io.BufferedInputStream;
import java.io.BufferedOutputStream;
import java.io.DataInputStream;
import java.io.DataOutputStream;
 
/**
 * 将Android中使用的gradle缓存目录中的jar包重新处理路径，用于内网离线构建
 * @author yhh
 *
 */
public class CopyTool {
    // static String path = "D:\\Androidstudio2.3.3\\Android Studio\\gradle\\m2repository";
    // static String path = "D:\\gradle_cache\\files-2.1";
    static String path = "D:\\test\\files-2.1"; //C:\Users\Administrator\.gradle\caches\modules-2\files-2.1
    // static String stopName= "files-2.1";
    static String stopName = "files-2.1";
 
    public static void main(String[] args) {
        System.out.println("Begin to copy");
        processDotForld();
        copyToLastForld();
        System.out.println("Copy finished");
    }
 
    /**
     * 处理文件夹中带点好的。；例如：D:/test/com.ifind.android/
     */
    public static void processDotForld() {
        File file = new File(path);
        if (file.exists()) {
            LinkedList<File> list = new LinkedList<>();
            File[] files = file.listFiles();
            for (int i = 0; i < files.length; i++) {
                File file2 = files[i];
                if (file2.isDirectory()) {
                    //文件夹
                    File desFile = creatforld(file2);
                    copyFileToDes(file2, desFile);
                } else {
                    //文件//目前不存在
                }
            }
        }
    }
 
    /**
     * 文件夹拷贝
     *
     * @param source
     * @param des
     */
    public static void copyFileToDes(File source, File des) {
        try {
            copyDir(source.getPath(), des.getPath());
        } catch (Exception e) {
            // TODO: handle exception
        }
    }
 
    /**
     * 文件夹拷贝
     *
     * @param sourcePath
     * @param newPath
     * @throws IOException
     */
    public static void copyDir(String sourcePath, String newPath) throws IOException {
        File file = new File(sourcePath);
        String[] filePath = file.list();
 
        if (!(new File(newPath)).exists()) {
            (new File(newPath)).mkdir();
        }
 
        for (int i = 0; i < filePath.length; i++) {
            if ((new File(sourcePath + file.separator + filePath[i])).isDirectory()) {
                copyDir(sourcePath + file.separator + filePath[i], newPath + file.separator + filePath[i]);
            }
 
            if (new File(sourcePath + file.separator + filePath[i]).isFile()) {
                copyFile(sourcePath + file.separator + filePath[i], newPath + file.separator + filePath[i]);
            }
 
        }
    }
 
    public static void copyFile(String oldPath, String newPath) throws IOException {
        File oldFile = new File(oldPath);
        File file = new File(newPath);
        FileInputStream in = new FileInputStream(oldFile);
        FileOutputStream out = new FileOutputStream(file);
 
        byte[] buffer = new byte[2097152];
 
        //while((in.read(buffer)) != -1){
        //  out.write(buffer);
        //}
 
        DataInputStream dis = new DataInputStream(new BufferedInputStream(in));
        DataOutputStream dos = new DataOutputStream(new BufferedOutputStream(out));
 
        int length;
        while ((length = dis.read(buffer)) != -1) {
            dos.write(buffer, 0, length);
        }
        dos.flush();
        dos.close();
        dis.close();
    }
 
 
    /**
     * 创建文件夹
     *
     * @param file
     */
    public static File creatforld(File file) {
        String path = file.getAbsolutePath();
        if (path != null) {
            String temp = "files-2.1";
            temp = stopName;
            String temS[] = path.split(temp);
 
            if (temS != null && temS.length == 2) {
                String firstName = temS[0];
                String dotName = temS[1];
                if (dotName != null) {
                    String[] lasts = dotName.split("\\.");
                    int count = lasts.length;
                    if (count < 2) {
                        return null;
                    }
                    String pathNew = firstName + temp;
                    for (int i = 0; i < count; i++) {
                        if (i == 0) {
                            pathNew = pathNew + lasts[i];
                        } else {
                            pathNew = pathNew + "\\" + lasts[i];
                        }
                    }
                    if (pathNew != null && !pathNew.equals("")) {
                        File fileForld = new File(pathNew);
                        if (!fileForld.exists()) {
                            fileForld.mkdirs();
                        }
                        return fileForld;
                    }
                }
            }
        }
        return null;
    }
 
    public static ArrayList<File> getFile(File file) {
        ArrayList<File> list = new ArrayList<>();
        if (file.isDirectory()) {
            File[] filesTemp = file.listFiles();
            for (int i = 0; i < filesTemp.length; i++) {
                ArrayList<File> result = getFile(filesTemp[i]);
                list.addAll(result);
            }
 
        } else {
            list.add(file);
        }
        return list;
    }
 
 
    // 创建目录
    public static boolean createDir(String destDirName) {
        File dir = new File(destDirName);
        if (dir.exists()) {// 判断目录是否存在
            System.out.println("创建目录失败，目标目录已存在！");
            return false;
        }
        if (!destDirName.endsWith(File.separator)) {// 结尾是否以"/"结束
            destDirName = destDirName + File.separator;
        }
        if (dir.mkdirs()) {// 创建目标目录
            System.out.println("创建目录成功！" + destDirName);
            return true;
        } else {
            System.out.println("创建目录失败！");
            return false;
        }
    }
 
 
    public static void copyToLastForld() {
        File file = new File(path);
        if (file.exists()) {
            LinkedList<File> list = new LinkedList<>();
            File[] files = file.listFiles();
            for (int i = 0; i < files.length; i++) {
                File file2 = files[i];
                if (file2.isDirectory()) {
                  //文件夹
                    proceessForld(file2);
                } else {
                  //文件//目前不存在
                }
            }
        }
    }
 
 
    private static void proceessForld(File file) {
        File[] files = file.listFiles();
        for (int i = 0; i < files.length; i++) {
            File file2 = files[i];
            if (file2.isDirectory()) {
                  //文件夹
                proceessForld(file2);
            } else {
                  //文件//目前不存在//判断是否进行拷贝
                try {
                    proceessFile(file2);
                } catch (FileNotFoundException e) {
                  // TODO Auto-generated catch block
                    e.printStackTrace();
                }
            }
        }
    }
 
 
    private static void proceessFile(File file) throws FileNotFoundException {
        if (file != null) {
            String path = file.getAbsolutePath();
            if (path != null) {
                String[] lasts = splitString(path);
                if (lasts != null && lasts.length > 0) {
                    int count = lasts.length;
                    String last = lasts[count - 1];
                    String last2 = lasts[count - 2];
 
 
                    if (last2 != null && last2.length() > 20) {
                  //拷贝到上一级目录
                        String des = null;
                        if (count < 2) {
                            return;
                        }
                        for (int i = 0; i < count - 2; i++) {
                            if (i == 0) {
                                des = lasts[i];
                            } else {
                                des = des + "\\\\" + lasts[i];
                            }
                        }
                        des = des + "\\\\" + last;
                        String strParentDirectory = file.getParent();
                        File parentFile = new File(strParentDirectory);
                        strParentDirectory = parentFile.getParent() + "\\" + last;
                        copy(file, path, strParentDirectory);
                    } else {
                  // System.out.println("source = "+path);
                    }
                  // System.out.println("source = "+path);
                  // System.out.println("des = "+des);
                }
            }
        }
    }
 
 
    private static String[] splitString(String path) {
        String[] lasts = null;
        lasts = path.split("\\\\");
        int count = lasts.length;
        boolean isFirst = true;
        for (int i = 0; i < count; i++) {
            String str = lasts[i];
            if (str != null && str.contains(".")) {
                if (isFirst) {
                    isFirst = false;
                    System.out.println("\n\n\n\n");
                    System.out.println("path=" + path + "");
                }
                System.out.println("str=" + str + "");
            }
        }
        return lasts;
    }
 
    /**
     * copy动作
     *
     * @param file
     * @param source
     * @param des
     * @throws FileNotFoundException
     */
    private static void copy(File file, String source, String des) throws FileNotFoundException {
        if (file != null) {
            FileInputStream fis = null;
            FileOutputStream fot = null;
            byte[] bytes = new byte[1024];
            int temp = 0;
            File desFile = new File(des);
            if (desFile.exists()) {
                return;
            }
            try {
                fis = new FileInputStream(file);
                fot = new FileOutputStream(desFile);
                while ((temp = fis.read(bytes)) != -1) {
                    fot.write(bytes, 0, temp);
                    fot.flush();
 
 
                }
            } catch (IOException e) {
                e.printStackTrace();
            } finally {
                if (fis != null) {
                    try {
                        fis.close();
                    } catch (IOException e) {
                        e.printStackTrace();
                    }
                }
                if (fot != null) {
                    try {
                        fot.close();
                    } catch (IOException e) {
                        e.printStackTrace();
                    }
                }
            }
 
 
        }
    }
 
 
    private static String getContent(String content) {
        String str = content;
        if (content != null && content.length() > 4) {
            str = content.substring(0, 4);
        }
        return str;
    }
}
 

等处理完，在文件夹里按时间排序，修改前文件夹名称里会带有.的路径，修改后的就是一层一层的了，把修改的文件夹复制到官方依赖库里就可以了

9.到这里就配置完成了，去studio重新编译一下就可以了，这里注意一点，在project下的build.gradle里之前依赖的仓库都不能用了，都注释掉