How to programmatically zip a file in Android?

I know this question already exists, but I'm not sure how to implement it in my case...

First I created an DataOutuputStream that will write in a file with .uedl extension:

private static DataOutputStream os;
public static final String BASE_PATH = Environment.getExternalStorageDirectory().getAbsolutePath() + "/myApp/logs/"


public static void startReceiveLogs() {
    if (debugBaudRate > -1) {
        mReadFlag = true;
        String time = TimeUtils.getCurrentTime(TimeZone.getDefault());
        try {
            os = new DataOutputStream(new FileOutputStream(BASE_PATH + time + "_logs.uedl"));
        } catch (FileNotFoundException e) {
            e.printStackTrace();
        }
        mReceiveLogsThread = new Thread(new ReceiveLogsThread());
        mReceiveLogsThread.start();
    }
}

Here is the writing stuff:

        public void run() {
        byte[] rbuf = new byte[64];
        while (mReadFlag) {
            try {
                int len = mSerial.readLog(rbuf, mSerialPortLog);
                if (len > 0) {
                    os.write(rbuf, 0, len);
                }
            } catch (NullPointerException e1) {
                e1.printStackTrace();
            } catch (Exception e) {
                e.printStackTrace();
            }
        }
    }

Once this thread stops running, I'd like to compress that file at the same path.

You try this it will help for you

 public boolean zipFileAtPath(String sourcePath, String toLocation) {
    final int BUFFER = 2048;

    File sourceFile = new File(sourcePath);
    try {
        BufferedInputStream origin = null;
        FileOutputStream dest = new FileOutputStream(toLocation);
        ZipOutputStream out = new ZipOutputStream(new BufferedOutputStream(
                dest));
        if (sourceFile.isDirectory()) {
            zipSubFolder(out, sourceFile, sourceFile.getParent().length());
        } else {
            byte data[] = new byte[BUFFER];
            FileInputStream fi = new FileInputStream(sourcePath);
            origin = new BufferedInputStream(fi, BUFFER);
            ZipEntry entry = new ZipEntry(getLastPathComponent(sourcePath));
            entry.setTime(sourceFile.lastModified()); // to keep modification time after unzipping
            out.putNextEntry(entry);
            int count;
            while ((count = origin.read(data, 0, BUFFER)) != -1) {
                out.write(data, 0, count);
            }
        }
        out.close();
    } catch (Exception e) {
        e.printStackTrace();
        return false;
    }
    return true;
}


 private void zipSubFolder(ZipOutputStream out, File folder,
                          int basePathLength) throws IOException {

    final int BUFFER = 2048;

    File[] fileList = folder.listFiles();
    BufferedInputStream origin = null;
    for (File file : fileList) {
        if (file.isDirectory()) {
            zipSubFolder(out, file, basePathLength);
        } else {
            byte data[] = new byte[BUFFER];
            String unmodifiedFilePath = file.getPath();
            String relativePath = unmodifiedFilePath
                    .substring(basePathLength);
            FileInputStream fi = new FileInputStream(unmodifiedFilePath);
            origin = new BufferedInputStream(fi, BUFFER);
            ZipEntry entry = new ZipEntry(relativePath);
            entry.setTime(file.lastModified()); // to keep modification time after unzipping
            out.putNextEntry(entry);
            int count;
            while ((count = origin.read(data, 0, BUFFER)) != -1) {
                out.write(data, 0, count);
            }
            origin.close();
        }
    }
}

  public String getLastPathComponent(String filePath) {
    String[] segments = filePath.split("/");
    if (segments.length == 0)
        return "";
    String lastPathComponent = segments[segments.length - 1];
    return lastPathComponent;
}