I am currently trying to re-create a project from Python into Android Application. But I am currently stuck with something I don’t literally know.
My Project is called “Passworder” (for generating German Passwords). And to make the password to generate NOT random letters, I want to generate words from “WordList.txt” from assets folder.
The Problem is, that I don’t even know, how to generate random words. With minimalLength and replacementRule, then I can do it.
Some code from my void:
// GeneratedActivity
private String generatePassword(int minLength, String charactersInBetween, @org.jetbrains.annotations.NotNull ArrayList<HashMap<String, Object>> replacementRule) {
String wordList = FileUtil.readFile(getAssets() + "WordList.txt");
String output = "";
for (int i = 0; i < replacementRule.size(); i++) {
output = output.replaceAll(replacementRule.get(i).get("replaceFrom").toString(), replacementRule.get(i).get("replaceTo").toString());
}
return output;
}
// FileUtil.readFile(String path)
public static String readFile(String path) {
createNewFile(path);
StringBuilder sb = new StringBuilder();
FileReader fr = null;
try {
fr = new FileReader(new File(path));
char[] buff = new char[1024];
int length = 0;
while ((length = fr.read(buff)) > 0) {
sb.append(new String(buff, 0, length));
}
} catch (IOException e) {
e.printStackTrace();
} finally {
if (fr != null) {
try {
fr.close();
} catch (Exception e) {
e.printStackTrace();
}
}
}
return sb.toString();
}Yes, that code is even from that application “Sketchware”
EDIT (of my full GeneratedActivity.java)
package com.bechrisapps.passworder;
import androidx.appcompat.app.AppCompatActivity;
import android.content.ClipData;
import android.content.ClipboardManager;
import android.content.Context;
import android.os.Bundle;
import android.view.View;
import android.widget.Button;
import android.widget.TextView;
import com.bechrisapps.passworder.utility.FileUtil;
import java.util.ArrayList;
import java.util.HashMap;
import org.jetbrains.annotations.NotNull;
public class GeneratedActivity extends AppCompatActivity {
public static int MINIMAL_LENGTH = 1;
public static String CHARACTER_IN_BETWEEN = "";
public static ArrayList<HashMap<String, Object>> REPLACEMENT_RULE = MainActivity.replacementRule;
private String replaceFrom = "", replaceTo = "";
private TextView textView;
private Button btnGenerate, btnCopy;
@Override
protected void onCreate(Bundle savedInstanceState) {
super.onCreate(savedInstanceState);
setContentView(R.layout.activity_generated);
initialize();
initializeLogic();
}
private void initialize() {
textView = findViewById(R.id.generated_password);
btnGenerate = findViewById(R.id.generated_renew);
btnCopy = findViewById(R.id.generated_copy);
btnCopy.setOnClickListener(new View.OnClickListener() {
@Override
public void onClick(View v) {
ClipboardManager clipboardManager = (ClipboardManager) getSystemService(Context.CLIPBOARD_SERVICE);
ClipData clip = ClipData.newPlainText("copiedPassword", textView.getText().toString());
clipboardManager.setPrimaryClip(clip);
}
});
}
private void initializeLogic() {
generatePassword(MINIMAL_LENGTH, CHARACTER_IN_BETWEEN, REPLACEMENT_RULE);
}
private String generatePassword(int minLength, String charactersInBetween, @NotNull ArrayList<HashMap<String, Object>> replacementRule) {
String wordList = FileUtil.readFile(getAssets() + "WordList.txt");
String output = "";
for (int i = 0; i < replacementRule.size(); i++) {
output = output.replaceAll(replacementRule.get(i).get("replaceFrom").toString(), replacementRule.get(i).get("replaceTo").toString());
}
return output;
}
}FileUtil.java
package com.bechrisapps.passworder.utility;
import android.content.ContentResolver;
import android.content.ContentUris;
import android.content.Context;
import android.database.Cursor;
import android.graphics.Bitmap;
import android.graphics.BitmapFactory;
import android.graphics.Canvas;
import android.graphics.ColorFilter;
import android.graphics.ColorMatrix;
import android.graphics.ColorMatrixColorFilter;
import android.graphics.LightingColorFilter;
import android.graphics.Matrix;
import android.graphics.Paint;
import android.graphics.PorterDuff;
import android.graphics.PorterDuffXfermode;
import android.graphics.Rect;
import android.graphics.RectF;
import android.media.ExifInterface;
import android.net.Uri;
import android.os.Environment;
import android.provider.DocumentsContract;
import android.provider.MediaStore;
import android.text.TextUtils;
import android.util.Log;
import java.io.BufferedInputStream;
import java.io.BufferedOutputStream;
import java.io.File;
import java.io.FileInputStream;
import java.io.FileNotFoundException;
import java.io.FileOutputStream;
import java.io.FileReader;
import java.io.FileWriter;
import java.io.IOException;
import java.net.URLDecoder;
import java.text.SimpleDateFormat;
import java.util.ArrayList;
import java.util.Date;
import java.util.zip.ZipEntry;
import java.util.zip.ZipInputStream;
import java.util.zip.ZipOutputStream;
public class FileUtil {
private static void createNewFile(String path) {
int lastSep = path.lastIndexOf(File.separator);
if (lastSep > 0) {
String dirPath = path.substring(0, lastSep);
makeDir(dirPath);
}
File file = new File(path);
try {
if (!file.exists())
file.createNewFile();
} catch (IOException e) {
e.printStackTrace();
}
}
public static String readFile(String path) {
createNewFile(path);
StringBuilder sb = new StringBuilder();
FileReader fr = null;
try {
fr = new FileReader(new File(path));
char[] buff = new char[1024];
int length = 0;
while ((length = fr.read(buff)) > 0) {
sb.append(new String(buff, 0, length));
}
} catch (IOException e) {
e.printStackTrace();
} finally {
if (fr != null) {
try {
fr.close();
} catch (Exception e) {
e.printStackTrace();
}
}
}
return sb.toString();
}
public static void writeFile(String path, String str) {
createNewFile(path);
FileWriter fileWriter = null;
try {
fileWriter = new FileWriter(new File(path), false);
fileWriter.write(str);
fileWriter.flush();
} catch (IOException e) {
e.printStackTrace();
} finally {
try {
if (fileWriter != null)
fileWriter.close();
} catch (IOException e) {
e.printStackTrace();
}
}
}
public static void copyFile(String sourcePath, String destPath) {
if (!isExistFile(sourcePath)) return;
createNewFile(destPath);
FileInputStream fis = null;
FileOutputStream fos = null;
try {
fis = new FileInputStream(sourcePath);
fos = new FileOutputStream(destPath, false);
byte[] buff = new byte[1024];
int length = 0;
while ((length = fis.read(buff)) > 0) {
fos.write(buff, 0, length);
}
} catch (IOException e) {
e.printStackTrace();
} finally {
if (fis != null) {
try {
fis.close();
} catch (IOException e) {
e.printStackTrace();
}
}
if (fos != null) {
try {
fos.close();
} catch (IOException e) {
e.printStackTrace();
}
}
}
}
public static void moveFile(String sourcePath, String destPath) {
copyFile(sourcePath, destPath);
deleteFile(sourcePath);
}
public static void deleteFile(String path) {
File file = new File(path);
if (!file.exists()) return;
if (file.isFile()) {
file.delete();
return;
}
File[] fileArr = file.listFiles();
if (fileArr != null) {
for (File subFile : fileArr) {
if (subFile.isDirectory()) {
deleteFile(subFile.getAbsolutePath());
}
if (subFile.isFile()) {
subFile.delete();
}
}
}
file.delete();
}
public static boolean isExistFile(String path) {
File file = new File(path);
return file.exists();
}
public static void makeDir(String path) {
if (!isExistFile(path)) {
File file = new File(path);
file.mkdirs();
}
}
public static void listDir(String path, ArrayList<String> list) {
File dir = new File(path);
if (!dir.exists() || dir.isFile()) return;
File[] listFiles = dir.listFiles();
if (listFiles == null || listFiles.length <= 0) return;
if (list == null) return;
list.clear();
for (File file : listFiles) {
list.add(file.getAbsolutePath());
}
}
public static boolean isDirectory(String path) {
if (!isExistFile(path)) return false;
return new File(path).isDirectory();
}
public static boolean isFile(String path) {
if (!isExistFile(path)) return false;
return new File(path).isFile();
}
public static long getFileLength(String path) {
if (!isExistFile(path)) return 0;
return new File(path).length();
}
public static String getExternalStorageDir() {
return Environment.getExternalStorageDirectory().getAbsolutePath();
}
public static String getPackageDataDir(Context context) {
return context.getExternalFilesDir(null).getAbsolutePath();
}
public static String getPackageObbDir() {
return FileUtil.getExternalStorageDir() + "/Android/obb/com.theblacklistedgame.blacklisted";
}
public static String getPublicDir(String type) {
return Environment.getExternalStoragePublicDirectory(type).getAbsolutePath();
}
public static String convertUriToFilePath(final Context context, final Uri uri) {
String path = null;
if (DocumentsContract.isDocumentUri(context, uri)) {
if (isExternalStorageDocument(uri)) {
final String docId = DocumentsContract.getDocumentId(uri);
final String[] split = docId.split(":");
final String type = split[0];
if ("primary".equalsIgnoreCase(type)) {
path = Environment.getExternalStorageDirectory() + "/" + split[1];
}
} else if (isDownloadsDocument(uri)) {
final String id = DocumentsContract.getDocumentId(uri);
if (!TextUtils.isEmpty(id)) {
if (id.startsWith("raw:")) {
return id.replaceFirst("raw:", "");
}
}
final Uri contentUri = ContentUris
.withAppendedId(Uri.parse("content://downloads/public_downloads"), Long.valueOf(id));
path = getDataColumn(context, contentUri, null, null);
} else if (isMediaDocument(uri)) {
final String docId = DocumentsContract.getDocumentId(uri);
final String[] split = docId.split(":");
final String type = split[0];
Uri contentUri = null;
if ("image".equals(type)) {
contentUri = MediaStore.Images.Media.EXTERNAL_CONTENT_URI;
} else if ("video".equals(type)) {
contentUri = MediaStore.Video.Media.EXTERNAL_CONTENT_URI;
} else if ("audio".equals(type)) {
contentUri = MediaStore.Audio.Media.EXTERNAL_CONTENT_URI;
}
final String selection = MediaStore.Audio.Media._ID + "=?";
final String[] selectionArgs = new String[]{
split[1]
};
path = getDataColumn(context, contentUri, selection, selectionArgs);
}
} else if (ContentResolver.SCHEME_CONTENT.equalsIgnoreCase(uri.getScheme())) {
path = getDataColumn(context, uri, null, null);
} else if (ContentResolver.SCHEME_FILE.equalsIgnoreCase(uri.getScheme())) {
path = uri.getPath();
}
if (path != null) {
try {
return URLDecoder.decode(path, "UTF-8");
} catch (Exception e) {
return null;
}
}
return null;
}
private static String getDataColumn(Context context, Uri uri, String selection, String[] selectionArgs) {
Cursor cursor = null;
final String column = MediaStore.Images.Media.DATA;
final String[] projection = {
column
};
try {
cursor = context.getContentResolver().query(uri, projection, selection, selectionArgs, null);
if (cursor != null && cursor.moveToFirst()) {
final int column_index = cursor.getColumnIndexOrThrow(column);
return cursor.getString(column_index);
}
} catch (Exception e) {
} finally {
if (cursor != null) {
cursor.close();
}
}
return null;
}
private static boolean isExternalStorageDocument(Uri uri) {
return "com.android.externalstorage.documents".equals(uri.getAuthority());
}
private static boolean isDownloadsDocument(Uri uri) {
return "com.android.providers.downloads.documents".equals(uri.getAuthority());
}
private static boolean isMediaDocument(Uri uri) {
return "com.android.providers.media.documents".equals(uri.getAuthority());
}
private static final int BUFFER_SIZE = 8192;
private static String TAG = FileUtil.class.getName();
private static String parentPath = "";
public static boolean zip(String sourcePath, String destinationPath, String destinationFileName, Boolean includeParentFolder) {
new File(destinationPath).mkdirs();
FileOutputStream fileOutputStream;
ZipOutputStream zipOutputStream = null;
try {
if (!destinationPath.endsWith("/")) destinationPath += "/";
String destination = destinationPath + destinationFileName;
File file = new File(destination);
if (!file.exists()) file.createNewFile();
fileOutputStream = new FileOutputStream(file);
zipOutputStream = new ZipOutputStream(new BufferedOutputStream(fileOutputStream));
if (includeParentFolder)
parentPath = new File(sourcePath).getParent() + "/";
else
parentPath = sourcePath;
zipFile(zipOutputStream, sourcePath);
} catch (IOException ioe) {
Log.d(TAG, ioe.getMessage());
return false;
} finally {
if (zipOutputStream != null)
try {
zipOutputStream.close();
} catch (IOException e) {
e.printStackTrace();
}
}
return true;
}
private static void zipFile(ZipOutputStream zipOutputStream, String sourcePath) throws IOException {
File files = new File(sourcePath);
File[] fileList = files.listFiles();
String entryPath = "";
BufferedInputStream input;
for (File file : fileList) {
if (file.isDirectory()) {
zipFile(zipOutputStream, file.getPath());
} else {
byte data[] = new byte[BUFFER_SIZE];
FileInputStream fileInputStream = new FileInputStream(file.getPath());
input = new BufferedInputStream(fileInputStream, BUFFER_SIZE);
entryPath = file.getAbsolutePath().replace(parentPath, "");
ZipEntry entry = new ZipEntry(entryPath);
zipOutputStream.putNextEntry(entry);
int count;
while ((count = input.read(data, 0, BUFFER_SIZE)) != -1) {
zipOutputStream.write(data, 0, count);
}
input.close();
}
}
}
public static Boolean unzip(String sourceFile, String destinationFolder) {
ZipInputStream zis = null;
try {
zis = new ZipInputStream(new BufferedInputStream(new FileInputStream(sourceFile)));
ZipEntry ze;
int count;
byte[] buffer = new byte[BUFFER_SIZE];
while ((ze = zis.getNextEntry()) != null) {
String fileName = ze.getName();
fileName = fileName.substring(fileName.indexOf("/") + 1);
File file = new File(destinationFolder, fileName);
File dir = ze.isDirectory() ? file : file.getParentFile();
if (!dir.isDirectory() && !dir.mkdirs())
throw new FileNotFoundException("Invalid path: " + dir.getAbsolutePath());
if (ze.isDirectory()) continue;
FileOutputStream fout = new FileOutputStream(file);
try {
while ((count = zis.read(buffer)) != -1)
fout.write(buffer, 0, count);
} finally {
fout.close();
}
}
} catch (IOException ioe) {
Log.d(TAG, ioe.getMessage());
return false;
} finally {
if (zis != null)
try {
zis.close();
} catch (IOException e) {
}
}
return true;
}
}Advertisement
Answer
This post is old, but I have the solution on who cannot progress with making passwords using a wordlist.
Obviously, first, read the file (can be from Storage or Assets) and test if that works. If this works, then create a random number picker and paste this following code:
public static int getRandomNumber(int min, int max) {
return new Random().nextInt(max - min + 1) + min;
}
To get a random word out of the Wordlist, use
String[] lines = content.split(System.lineSeparator()); int random = getRandomNumber(0, lines.length); String word = lines[random];
And to generate a new password, it is recommended to use while to loop, until it hits the minimal length (currentPassword is a String and I copied the code from my project (see on my GitHub page))
private void generateNewPassword() {
currentPassword = "";
while (currentPassword.length() <= minLength)
currentPassword += lines[Utility.getRandomNumber(0, lines.length - 1)] + charsBetweenWords;
if (replacesChars) {
for (int i = 0; i < listFrom.size(); i++) {
if (replacesCases) {
String lowercase = listFrom.get(i).toLowerCase();
String uppercase = listFrom.get(i).toUpperCase();
currentPassword = currentPassword.replaceAll(lowercase, listTo.get(i));
currentPassword = currentPassword.replaceAll(uppercase, listTo.get(i));
} else {
if (listTo.get(i).equals("$"))
currentPassword = currentPassword.replaceAll(listFrom.get(i), "\$");
else if (listFrom.get(i).equals("$"))
currentPassword = currentPassword.replaceAll("\$", listTo.get(i));
else if (listTo.get(i).equals("\"))
currentPassword = currentPassword.replaceAll(listFrom.get(i), "\");
else if (listFrom.get(i).equals("\"))
currentPassword = currentPassword.replaceAll("\\", listTo.get(i));
else
currentPassword = currentPassword.replaceAll(listFrom.get(i), listTo.get(i));
}
}
}
currentPassword = currentPassword.substring(0, currentPassword.length() - charsBetweenWords.length());
passwordOutput.setText(currentPassword);
}