Add zip creation of SD card data.

This uses the miniz library, which is self-contained in a single
.c/.h pair and has an MIT license.

Swapping out the zip library should be fairly straightforward
if ever necessary.

oscar/mainwindow.cpp

@@ -59,6 +59,7 @@
 
 #include "reports.h"
 #include "statistics.h"
+#include "zip.h"
 
 #if QT_VERSION >= QT_VERSION_CHECK(5,4,0)
 #include <QOpenGLFunctions>
@@ -2591,6 +2592,7 @@ void MainWindow::on_actionCreate_Card_zip_triggered()
     QList<ImportPath> datacards = selectCPAPDataCards(tr("Would you like to archive this card?"));
 
     for (auto & datacard : datacards) {
+        QString cardPath = QDir(datacard.path).canonicalPath();
         QString filename;
         
         // Loop until a valid folder is selected or the user cancels. Disallow the SD card itself!
@@ -2614,7 +2616,6 @@ void MainWindow::on_actionCreate_Card_zip_triggered()
             }
             
             // Try again if the selected filename is within the SD card itself.
-            QString cardPath = QDir(datacard.path).canonicalPath();
             QString selectedPath = QFileInfo(filename).dir().canonicalPath();
             if (selectedPath.startsWith(cardPath)) {
                 if (QMessageBox::warning(nullptr, STR_MessageBox_Error,
@@ -2631,9 +2632,23 @@ void MainWindow::on_actionCreate_Card_zip_triggered()
             filename += ".zip";
         }
         
-        qDebug() << "Create zip of SD card:" << filename;
+        qDebug() << "Create zip of SD card:" << cardPath;
 
-        // TODO: implement creation of .zip
+        ZipFile z;
+        bool ok = z.Open(filename);
+        if (ok) {
+            // TODO: need to add progress bar!
+            ok = z.Add(cardPath);
+            z.Close();
+        }
+        if (!ok) {
+            qWarning() << "Unable to create" << filename;
+            QMessageBox::warning(nullptr, STR_MessageBox_Error,
+                QObject::tr("Unable to create archive!"),
+                QMessageBox::Ok);
+        } else {
+            qDebug() << "Created" << filename;
+        }
     }
 }
 

oscar/oscar.pro

@@ -293,6 +293,8 @@ SOURCES += \
     SleepLib/loader_plugins/resmed_loader.cpp \
     SleepLib/loader_plugins/somnopose_loader.cpp \
     SleepLib/loader_plugins/zeo_loader.cpp \
+    zip.cpp \
+    miniz.c \
     translation.cpp \
     statistics.cpp \
     oximeterimport.cpp \
@@ -365,6 +367,8 @@ HEADERS  += \
     SleepLib/loader_plugins/resmed_loader.h \
     SleepLib/loader_plugins/somnopose_loader.h \
     SleepLib/loader_plugins/zeo_loader.h \
+    zip.h \
+    miniz.h \
     translation.h \
     statistics.h \
     oximeterimport.h \

oscar/zip.cpp

@@ -0,0 +1,205 @@
+/* OSCAR ZIP archive creation
+ * Provides a Qt-convenient wrapper around miniz, see https://github.com/richgel999/miniz
+ *
+ * Copyright (c) 2020 The OSCAR Team
+ *
+ * This file is subject to the terms and conditions of the GNU General Public
+ * License. See the file COPYING in the main directory of the source code
+ * for more details. */
+
+#include "zip.h"
+#include <QDebug>
+#include <QDateTime>
+
+
+// Static functions to abstract the details of miniz from the primary logic.
+static void* zip_init();
+static bool zip_open(void* ctx, QFile & file);
+static bool zip_add(void* ctx, const QString & archive_name, const QByteArray & data, const QDateTime & modified);
+static void zip_close(void* ctx);
+static void zip_done(void* ctx);
+
+
+ZipFile::ZipFile()
+{
+    m_ctx = zip_init();
+}
+
+ZipFile::~ZipFile()
+{
+    Close();
+    zip_done(m_ctx);
+}
+
+bool ZipFile::Open(const QString & filepath)
+{
+    m_file.setFileName(filepath);
+    bool ok = m_file.open(QIODevice::WriteOnly);
+    if (!ok) {
+        qWarning() << "unable to open" << m_file.fileName();
+        return false;
+    }
+    ok = zip_open(m_ctx, m_file);
+    return ok;
+}
+
+void ZipFile::Close()
+{
+    if (m_file.isOpen()) {
+        zip_close(m_ctx);
+        m_file.close();
+    }
+}
+
+bool ZipFile::Add(const QDir & root)
+{
+    return Add(root, root.dirName());
+}
+
+bool ZipFile::Add(const QDir & inDir, const QString & prefix)
+{
+    QDir dir(inDir);
+    
+    if (!dir.exists() || !dir.isReadable()) {
+        qWarning() << dir.canonicalPath() << "can't read directory";
+        return false;
+    }
+
+    // Add directory entry
+    bool ok = Add(dir.canonicalPath(), prefix);
+    if (!ok) {
+        return false;
+    }
+
+    dir.setFilter(QDir::NoDotAndDotDot | QDir::Dirs | QDir::Files | QDir::Hidden);
+    dir.setSorting(QDir::Name);
+    QFileInfoList flist = dir.entryInfoList();
+
+    for (auto & fi : flist) {
+        QString canonicalPath = fi.canonicalFilePath();
+        QString relative_path = prefix + QDir::separator() + fi.fileName();
+        if (fi.isSymLink()) {
+            qWarning() << "skipping symlink" << canonicalPath << fi.symLinkTarget();
+        } else if (fi.isDir()) {
+            // Descend and recurse
+            ok = Add(QDir(canonicalPath), relative_path);
+        } else {
+            // Add the file to the zip
+            ok = Add(canonicalPath, relative_path);
+        }
+        if (!ok) {
+            break;
+        }
+    }
+
+    return ok;
+}
+
+bool ZipFile::Add(const QString & path, const QString & prefix)
+{
+    if (!m_file.isOpen()) {
+        qWarning() << m_file.fileName() << "has not been opened for writing";
+        return false;
+    }
+
+    QFileInfo fi(path);
+    QByteArray data;
+    QString archive_name = prefix;
+
+    if (fi.isDir()) {
+        archive_name += QDir::separator();
+    } else {
+        // Open and read file into memory.
+        QFile f(path);
+        if (!f.open(QIODevice::ReadOnly)) {
+            qWarning() << path << "can't open";
+            return false;
+        }
+        data = f.readAll();
+    }
+
+    //qDebug() << "attempting to add" << archive_name << ":" << data.size() << "bytes";
+
+    bool ok = zip_add(m_ctx, archive_name, data, fi.lastModified());
+    return ok;
+}
+
+
+
+// ==================================================================================================
+// Static functions to abstract the details of miniz from the primary logic.
+
+#include "miniz.h"
+
+// Callback for miniz to write compressed data
+static size_t zip_write(void *pOpaque, mz_uint64 /*file_ofs*/, const void *pBuf, size_t n)
+{
+    if (pOpaque == nullptr) {
+        qCritical() << "null pointer passed to ZipFile::Write!";
+        return 0;
+    }
+    QFile* file = (QFile*) pOpaque;
+    size_t written = file->write((const char*) pBuf, n);
+    if (written < n) {
+        qWarning() << "error writing to" << file->fileName();
+    }
+    return written;
+}
+
+static void* zip_init()
+{
+    mz_zip_archive* pZip = new mz_zip_archive();  // zero-initializes struct
+    pZip->m_pWrite = zip_write;
+    return pZip;
+}
+
+static void zip_done(void* ctx)
+{
+    Q_ASSERT(ctx);
+    mz_zip_archive* pZip = (mz_zip_archive*) ctx;
+    delete pZip;
+}
+
+static bool zip_open(void* ctx, QFile & file)
+{
+    Q_ASSERT(ctx);
+    mz_zip_archive* pZip = (mz_zip_archive*) ctx;
+
+    pZip->m_pIO_opaque = &file;
+    bool ok = mz_zip_writer_init_v2(pZip, 0, MZ_ZIP_FLAG_CASE_SENSITIVE);
+    if (!ok) {
+        mz_zip_error mz_err = mz_zip_get_last_error(pZip);
+        qWarning() << "unable to initialize miniz writer" << MZ_VERSION << mz_zip_get_error_string(mz_err);
+    }
+    return ok;
+}
+
+static bool zip_add(void* ctx, const QString & archive_name, const QByteArray & data, const QDateTime & modified)
+{
+    Q_ASSERT(ctx);
+    mz_zip_archive* pZip = (mz_zip_archive*) ctx;
+    
+    // Add to .zip
+    time_t last_modified = modified.toTime_t();  // technically deprecated, but miniz expects a time_t
+    bool ok = mz_zip_writer_add_mem_ex_v2(pZip, archive_name.toLocal8Bit(), data.constData(), data.size(),
+                                          nullptr, 0,  // no comment
+                                          MZ_DEFAULT_COMPRESSION,
+                                          0, 0,  // not used when compressing data
+                                          &last_modified,
+                                          nullptr, 0,  // no user extra data
+                                          nullptr, 0   // no user extra data central
+                                         );
+    if (!ok) {
+        mz_zip_error mz_err = mz_zip_get_last_error(pZip);
+        qWarning() << "unable to add" << archive_name << ":" << data.size() << "bytes" << mz_zip_get_error_string(mz_err);
+    }
+    return ok;
+}
+
+static void zip_close(void* ctx)
+{
+    Q_ASSERT(ctx);
+    mz_zip_archive* pZip = (mz_zip_archive*) ctx;
+    mz_zip_writer_finalize_archive(pZip);
+    mz_zip_writer_end(pZip);
+}

oscar/zip.h

@@ -0,0 +1,29 @@
+/* OSCAR ZIP archive creation
+ * Provides a Qt-convenient wrapper around miniz, see https://github.com/richgel999/miniz
+ *
+ * Copyright (c) 2020 The OSCAR Team
+ *
+ * This file is subject to the terms and conditions of the GNU General Public
+ * License. See the file COPYING in the main directory of the source code
+ * for more details. */
+
+#include <QString>
+#include <QDir>
+#include <QFile>
+
+class ZipFile
+{
+public:
+    ZipFile();
+    virtual ~ZipFile();
+    
+    bool Open(const QString & filepath);
+    bool Add(const QDir & root);
+    bool Add(const QDir & dir, const QString & archive_name);  // add a directory and recurse
+    bool Add(const QString & path, const QString & archive_name);  // add a file and recurse
+    void Close();
+
+protected:
+    void* m_ctx;
+    QFile m_file;
+};