/* Copyright (C) 2024 Vitalii Tomin
|
|
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.huawei;
|
|
import android.content.ContentResolver;
|
import android.content.Context;
|
import android.database.Cursor;
|
import android.graphics.Bitmap;
|
import android.graphics.BitmapFactory;
|
import android.media.MediaExtractor;
|
import android.media.MediaMetadataRetriever;
|
import android.media.MediaFormat;
|
import android.net.Uri;
|
import android.provider.OpenableColumns;
|
import android.text.TextUtils;
|
|
import org.slf4j.Logger;
|
import org.slf4j.LoggerFactory;
|
|
import java.io.ByteArrayOutputStream;
|
import java.io.FileNotFoundException;
|
import java.io.IOException;
|
import java.io.InputStream;
|
import java.nio.ByteBuffer;
|
|
import nodomain.freeyourgadget.gadgetbridge.devices.huawei.HuaweiBinAppParser;
|
import nodomain.freeyourgadget.gadgetbridge.devices.huawei.packets.FileUpload;
|
import nodomain.freeyourgadget.gadgetbridge.util.GB;
|
import nodomain.freeyourgadget.gadgetbridge.util.GBZipFile;
|
import nodomain.freeyourgadget.gadgetbridge.util.UriHelper;
|
import nodomain.freeyourgadget.gadgetbridge.util.ZipFileException;
|
|
public class HuaweiFwHelper {
|
private static final Logger LOG = LoggerFactory.getLogger(HuaweiFwHelper.class);
|
|
private final Uri uri;
|
|
private byte[] fw;
|
private int fileSize = 0;
|
private byte fileType = 0;
|
String fileName = "";
|
|
Bitmap previewBitmap;
|
HuaweiWatchfaceManager.WatchfaceDescription watchfaceDescription;
|
HuaweiAppManager.AppConfig appConfig;
|
HuaweiMusicManager.AudioInfo musicInfo;
|
Context mContext;
|
|
|
|
public HuaweiFwHelper(final Uri uri, final Context context) {
|
|
this.uri = uri;
|
final UriHelper uriHelper;
|
this.mContext = context;
|
try {
|
uriHelper = UriHelper.get(uri, context);
|
} catch (final IOException e) {
|
LOG.error("Failed to get uri helper for {}", uri, e);
|
return;
|
}
|
|
parseFile();
|
}
|
|
private void parseFile() {
|
if (parseAsMusic()) {
|
fileType = FileUpload.Filetype.music;
|
} else if (parseAsApp()) {
|
assert appConfig.bundleName != null;
|
fileType = FileUpload.Filetype.app;
|
} else if (parseAsWatchFace()) {
|
assert watchfaceDescription.screen != null;
|
assert watchfaceDescription.title != null;
|
fileType = FileUpload.Filetype.watchface;
|
}
|
}
|
|
private String getNameWithoutExtension(String fileName) {
|
return fileName.indexOf(".") > 0?fileName.substring(0, fileName.lastIndexOf(".")): fileName;
|
}
|
|
private String getExtension(String fileName) {
|
if (TextUtils.isEmpty(fileName)) {
|
return null;
|
}
|
int lastIndexOf = fileName.lastIndexOf(".");
|
if (lastIndexOf >= 0 && lastIndexOf + 1 < fileName.length()) {
|
return fileName.substring(lastIndexOf + 1);
|
}
|
return null;
|
}
|
|
private HuaweiMusicManager.AudioInfo getAudioInfo(Uri selectedUri) throws IOException {
|
ContentResolver contentResolver = mContext.getContentResolver();
|
String[] filePathColumn = {OpenableColumns.DISPLAY_NAME, OpenableColumns.SIZE};
|
|
Cursor cursor = contentResolver.query(selectedUri, filePathColumn, null, null, null);
|
if(cursor == null)
|
return null;
|
cursor.moveToFirst();
|
|
int fileNameIndex = cursor.getColumnIndex(filePathColumn[0]);
|
String fileName = cursor.getString(fileNameIndex);
|
int fileSizeIndex = cursor.getColumnIndex(filePathColumn[1]);
|
long fileSize = cursor.getLong(fileSizeIndex);
|
cursor.close();
|
|
MediaMetadataRetriever mmr = new MediaMetadataRetriever();
|
mmr.setDataSource(mContext, selectedUri);
|
|
String title = mmr.extractMetadata(MediaMetadataRetriever.METADATA_KEY_TITLE);
|
String artist = mmr.extractMetadata(MediaMetadataRetriever.METADATA_KEY_ARTIST);
|
|
if(TextUtils.isEmpty(title)) {
|
title = getNameWithoutExtension(fileName);
|
}
|
if(TextUtils.isEmpty(artist)) {
|
artist = "Unknown";
|
}
|
|
MediaExtractor mex = new MediaExtractor();
|
mex.setDataSource(mContext, selectedUri, null);
|
|
|
MediaFormat mf = mex.getTrackFormat(0);
|
|
int bitrate = -1; // TODO: calculate or get bitrate
|
int sampleRate = mf.getInteger(MediaFormat.KEY_SAMPLE_RATE);
|
int channels = mf.getInteger(MediaFormat.KEY_CHANNEL_COUNT);
|
long duration = mf.getLong(MediaFormat.KEY_DURATION);
|
|
LOG.info("bitRate: " + bitrate);
|
LOG.info("sampleRate: " + sampleRate);
|
LOG.info("channelCount: " + channels);
|
LOG.info("duration: " + duration);
|
|
String extension = getExtension(fileName);
|
if(!TextUtils.isEmpty(extension)) {
|
extension = extension.toLowerCase();
|
}
|
|
HuaweiMusicManager.AudioInfo audioInfo = new HuaweiMusicManager.AudioInfo(fileName, fileSize, title, artist, extension);
|
audioInfo.setCharacteristics(duration, sampleRate, bitrate, (byte) channels);
|
|
return audioInfo;
|
}
|
|
private byte[] getFileData(UriHelper uriHelper) throws IOException {
|
InputStream inputStream = uriHelper.openInputStream();
|
ByteArrayOutputStream buffer = new ByteArrayOutputStream();
|
|
int nRead;
|
byte[] data = new byte[1000];
|
while ((nRead = inputStream.read(data, 0, data.length)) != -1) {
|
buffer.write(data, 0, nRead);
|
}
|
buffer.flush();
|
inputStream.close();
|
return buffer.toByteArray();
|
}
|
|
boolean parseAsMusic() {
|
try {
|
final UriHelper uriHelper = UriHelper.get(uri, this.mContext);
|
|
String mimeType = mContext.getContentResolver().getType(uri);
|
LOG.info("File mime type: {}", mimeType);
|
|
if(mimeType == null || !mimeType.startsWith("audio/"))
|
return false;
|
|
musicInfo = getAudioInfo(uri);
|
if(musicInfo == null)
|
return false;
|
|
musicInfo.setMimeType(mimeType);
|
|
byte[] musicData = getFileData(uriHelper);
|
|
fileName = musicInfo.getFileName();
|
fw = musicData;
|
fileSize = fw.length;
|
|
return true;
|
} catch (FileNotFoundException e) {
|
LOG.error("Music: File was not found {}", e.getMessage());
|
} catch (IOException e) {
|
LOG.error("Music: General IO error occurred {}", e.getMessage());
|
} catch (Exception e) {
|
LOG.error("Music: Unknown error occurred", e);
|
}
|
return false;
|
}
|
|
|
boolean parseAsApp() {
|
|
try {
|
final UriHelper uriHelper = UriHelper.get(uri, this.mContext);
|
|
byte[] appData = getFileData(uriHelper);
|
|
HuaweiBinAppParser app = new HuaweiBinAppParser();
|
app.parseData(appData);
|
|
byte[] config = app.getEntryContent("config.json");
|
if (config == null)
|
return false;
|
appConfig = new HuaweiAppManager.AppConfig(new String(config));
|
fileName = app.getPackageName() + "_INSTALL"; //TODO: INSTALL or UPDATE suffix
|
|
fw = appData;
|
fileSize = fw.length;
|
|
byte[] icon = app.getEntryContent("icon_small.png");
|
if (icon != null) {
|
previewBitmap = BitmapFactory.decodeByteArray(icon, 0, icon.length);
|
}
|
|
return true;
|
|
} catch (FileNotFoundException e) {
|
LOG.error("App: File was not found{}", e.getMessage());
|
} catch (IOException e) {
|
LOG.error("App: General IO error occurred {}", e.getMessage());
|
} catch (HuaweiBinAppParser.HuaweiBinAppParseError e) {
|
LOG.error("App: Error parsing app File {}", e.getMessage());
|
} catch (Exception e) {
|
LOG.error("App: Unknown error occurred", e);
|
}
|
return false;
|
}
|
|
|
public byte[] getBytes() {
|
return fw;
|
}
|
|
public void unsetFwBytes() {
|
this.fw = null;
|
}
|
|
boolean parseAsWatchFace() {
|
boolean isWatchface = false;
|
|
try {
|
final UriHelper uriHelper = UriHelper.get(uri, this.mContext);
|
|
GBZipFile watchfacePackage = new GBZipFile(uriHelper.openInputStream());
|
byte[] bytesDescription = watchfacePackage.getFileFromZip("description.xml");
|
|
// check if description file contents BOM
|
ByteBuffer bb = ByteBuffer.wrap(bytesDescription);
|
byte[] bom = new byte[3];
|
// get the first 3 bytes
|
bb.get(bom, 0, bom.length);
|
String content = new String(GB.hexdump(bom));
|
String xmlDescription = null;
|
if ("efbbbf".equalsIgnoreCase(content)) {
|
byte[] contentAfterFirst3Bytes = new byte[bytesDescription.length - 3];
|
bb.get(contentAfterFirst3Bytes, 0, contentAfterFirst3Bytes.length);
|
xmlDescription = new String(contentAfterFirst3Bytes);
|
} else {
|
xmlDescription = new String(bytesDescription);
|
}
|
|
watchfaceDescription = new HuaweiWatchfaceManager.WatchfaceDescription(xmlDescription);
|
if (watchfacePackage.fileExists("preview/cover.jpg")) {
|
final byte[] preview = watchfacePackage.getFileFromZip("preview/cover.jpg");
|
previewBitmap = BitmapFactory.decodeByteArray(preview, 0, preview.length);
|
}
|
|
byte[] watchfaceZip = watchfacePackage.getFileFromZip("com.huawei.watchface");
|
try {
|
GBZipFile watchfaceBinZip = new GBZipFile(watchfaceZip);
|
fw = watchfaceBinZip.getFileFromZip("watchface.bin");
|
} catch (ZipFileException e) {
|
LOG.error("Unable to get watchfaceZip, it seems older already watchface.bin");
|
fw = watchfaceZip;
|
}
|
fileSize = fw.length;
|
isWatchface = true;
|
|
} catch (ZipFileException e) {
|
LOG.error("Watchface: Unable to read file {}", e.getMessage());
|
} catch (FileNotFoundException e) {
|
LOG.error("Watchface: File was not found {}", e.getMessage());
|
} catch (IOException e) {
|
LOG.error("Watchface: General IO error occurred {}", e.getMessage());
|
} catch (Exception e) {
|
LOG.error("Watchface: Unknown error occurred", e);
|
}
|
|
return isWatchface;
|
}
|
|
public boolean isWatchface() {
|
return fileType == FileUpload.Filetype.watchface;
|
}
|
|
public boolean isAPP() {
|
return fileType == FileUpload.Filetype.app;
|
}
|
|
public boolean isMusic() {
|
return fileType == FileUpload.Filetype.music;
|
}
|
|
public boolean isValid() {
|
return isWatchface() || isAPP() || isMusic();
|
}
|
|
public Bitmap getPreviewBitmap() {
|
return previewBitmap;
|
}
|
|
public HuaweiWatchfaceManager.WatchfaceDescription getWatchfaceDescription() {
|
return watchfaceDescription;
|
}
|
|
public HuaweiAppManager.AppConfig getAppConfig() {
|
return appConfig;
|
}
|
|
public HuaweiMusicManager.AudioInfo getMusicInfo() {
|
return musicInfo;
|
}
|
|
public byte getFileType() {
|
return fileType;
|
}
|
|
public String getFileName() {
|
return fileName;
|
}
|
|
|
}
|
