/* Copyright (C) 2024 José Rebelo
|
|
This file is part of Gadgetbridge.
|
|
Gadgetbridge is free software: you can redistribute it and/or modify
|
it under the terms of the GNU Affero General Public License as published
|
by the Free Software Foundation, either version 3 of the License, or
|
(at your option) any later version.
|
|
Gadgetbridge is distributed in the hope that it will be useful,
|
but WITHOUT ANY WARRANTY; without even the implied warranty of
|
MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
|
GNU Affero General Public License for more details.
|
|
You should have received a copy of the GNU Affero General Public License
|
along with this program. If not, see <https://www.gnu.org/licenses/>. */
|
package nodomain.freeyourgadget.gadgetbridge.service.devices.cmfwatchpro;
|
|
import android.content.Context;
|
import android.net.Uri;
|
|
import org.slf4j.Logger;
|
import org.slf4j.LoggerFactory;
|
|
import java.io.BufferedInputStream;
|
import java.io.IOException;
|
import java.io.InputStream;
|
|
import nodomain.freeyourgadget.gadgetbridge.util.ArrayUtils;
|
import nodomain.freeyourgadget.gadgetbridge.util.FileUtils;
|
import nodomain.freeyourgadget.gadgetbridge.util.StringUtils;
|
import nodomain.freeyourgadget.gadgetbridge.util.UriHelper;
|
|
public class CmfFwHelper {
|
private static final Logger LOG = LoggerFactory.getLogger(CmfFwHelper.class);
|
|
private static final byte[] HEADER_WATCHFACE = new byte[]{0x01, 0x00, 0x00, 0x02};
|
private static final byte[] HEADER_FIRMWARE = new byte[]{'A', 'O', 'T', 'A'};
|
private static final byte[] HEADER_AGPS = new byte[]{0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x31, 0x30, 0x30, 0x30, 0x30};
|
|
private final Uri uri;
|
private byte[] fw;
|
private boolean typeFirmware;
|
private boolean typeWatchface;
|
private boolean typeAgps;
|
|
private String name;
|
private String version;
|
|
public CmfFwHelper(final Uri uri, final Context context) {
|
this.uri = uri;
|
|
final UriHelper uriHelper;
|
try {
|
uriHelper = UriHelper.get(uri, context);
|
} catch (final IOException e) {
|
LOG.error("Failed to get uri helper for {}", uri, e);
|
return;
|
}
|
|
final int maxExpectedFileSize = 1024 * 1024 * 32; // 32MB
|
|
if (uriHelper.getFileSize() > maxExpectedFileSize) {
|
LOG.warn("File size is larger than the maximum expected file size of {}", maxExpectedFileSize);
|
return;
|
}
|
|
try (final InputStream in = new BufferedInputStream(uriHelper.openInputStream())) {
|
this.fw = FileUtils.readAll(in, maxExpectedFileSize);
|
} catch (final IOException e) {
|
LOG.error("Failed to read bytes from {}", uri, e);
|
return;
|
}
|
|
parseBytes();
|
}
|
|
public Uri getUri() {
|
return uri;
|
}
|
|
public boolean isValid() {
|
return isWatchface() || isFirmware() || isAgps();
|
}
|
|
public boolean isWatchface() {
|
return typeWatchface;
|
}
|
|
public boolean isFirmware() {
|
return typeFirmware;
|
}
|
|
public boolean isAgps() {
|
return typeAgps;
|
}
|
|
public String getDetails() {
|
return name != null ? name : (version != null ? version : "UNKNOWN");
|
}
|
|
public byte[] getBytes() {
|
return fw;
|
}
|
|
public String getName() {
|
return name;
|
}
|
|
public String getVersion() {
|
return version;
|
}
|
|
public void unsetFwBytes() {
|
this.fw = null;
|
}
|
|
private void parseBytes() {
|
if (parseAsWatchface()) {
|
assert name != null;
|
typeWatchface = true;
|
} else if (parseAsFirmware()) {
|
assert version != null;
|
typeFirmware = true;
|
} else if (parseAsAgps()) {
|
typeAgps = true;
|
}
|
}
|
|
private boolean parseAsWatchface() {
|
if (!ArrayUtils.equals(fw, HEADER_WATCHFACE, 4)) {
|
LOG.warn("File header not a watchface");
|
return false;
|
}
|
|
final String nameHeader = StringUtils.untilNullTerminator(fw, 8);
|
if (nameHeader == null) {
|
LOG.warn("watchface name not found in {}", uri);
|
return false;
|
}
|
|
// Confirm it's a watchface by finding the same name at the end
|
final String nameTrailer = StringUtils.untilNullTerminator(fw, fw.length - 28);
|
if (nameTrailer == null) {
|
LOG.warn("watchface name not found at the end of {}", uri);
|
return false;
|
}
|
|
if (!nameHeader.equals(nameTrailer)) {
|
LOG.warn("Names in header and trailer do not match");
|
return false;
|
}
|
|
name = nameHeader;
|
|
return true;
|
}
|
|
private boolean parseAsFirmware() {
|
if (!ArrayUtils.equals(fw, HEADER_FIRMWARE, 0)) {
|
LOG.warn("File header not a firmware");
|
return false;
|
}
|
|
// FIXME: This is not really the version, but build number?
|
final String versionHeader = StringUtils.untilNullTerminator(fw, 64);
|
if (versionHeader == null) {
|
LOG.warn("firmware version not found in {}", uri);
|
return false;
|
}
|
|
version = versionHeader;
|
|
return true;
|
}
|
|
private boolean parseAsAgps() {
|
if (!ArrayUtils.equals(fw, HEADER_AGPS, 0)) {
|
LOG.warn("File header not agps");
|
return false;
|
}
|
|
// TODO parse? and set something
|
|
return true;
|
}
|
}
|
