mirror of
https://github.com/revanced/revanced-manager
synced 2024-05-14 13:56:57 +02:00
538 lines
18 KiB
Dart
538 lines
18 KiB
Dart
import 'package:flutter/material.dart';
|
|
import 'package:flutter/services.dart';
|
|
import 'package:flutter_file_dialog/flutter_file_dialog.dart';
|
|
import 'package:revanced_manager/gen/strings.g.dart';
|
|
import 'package:revanced_manager/models/patch.dart';
|
|
import 'package:revanced_manager/ui/widgets/shared/custom_card.dart';
|
|
|
|
class BooleanPatchOption extends StatelessWidget {
|
|
const BooleanPatchOption({
|
|
super.key,
|
|
required this.patchOption,
|
|
required this.removeOption,
|
|
required this.onChanged,
|
|
});
|
|
|
|
final Option patchOption;
|
|
final void Function(Option option) removeOption;
|
|
final void Function(dynamic value, Option option) onChanged;
|
|
|
|
@override
|
|
Widget build(BuildContext context) {
|
|
final ValueNotifier patchOptionValue = ValueNotifier(patchOption.value);
|
|
return PatchOption(
|
|
widget: Align(
|
|
alignment: Alignment.bottomLeft,
|
|
child: ValueListenableBuilder(
|
|
valueListenable: patchOptionValue,
|
|
builder: (context, value, child) {
|
|
return Switch(
|
|
value: value ?? false,
|
|
onChanged: (bool value) {
|
|
patchOptionValue.value = value;
|
|
onChanged(value, patchOption);
|
|
},
|
|
);
|
|
},
|
|
),
|
|
),
|
|
patchOption: patchOption,
|
|
removeOption: (Option option) {
|
|
removeOption(option);
|
|
},
|
|
);
|
|
}
|
|
}
|
|
|
|
class IntAndStringPatchOption extends StatelessWidget {
|
|
const IntAndStringPatchOption({
|
|
super.key,
|
|
required this.patchOption,
|
|
required this.removeOption,
|
|
required this.onChanged,
|
|
});
|
|
|
|
final Option patchOption;
|
|
final void Function(Option option) removeOption;
|
|
final void Function(dynamic value, Option option) onChanged;
|
|
|
|
@override
|
|
Widget build(BuildContext context) {
|
|
final ValueNotifier patchOptionValue = ValueNotifier(patchOption.value);
|
|
String getKey() {
|
|
if (patchOption.value != null && patchOption.values != null) {
|
|
final List values = patchOption.values!.entries
|
|
.where((e) => e.value == patchOption.value)
|
|
.toList();
|
|
if (values.isNotEmpty) {
|
|
return values.first.key;
|
|
}
|
|
}
|
|
return '';
|
|
}
|
|
|
|
return PatchOption(
|
|
widget: Column(
|
|
crossAxisAlignment: CrossAxisAlignment.start,
|
|
children: [
|
|
TextFieldForPatchOption(
|
|
value: patchOption.value,
|
|
values: patchOption.values,
|
|
optionType: patchOption.valueType,
|
|
selectedKey: getKey(),
|
|
onChanged: (value) {
|
|
patchOptionValue.value = value;
|
|
onChanged(value, patchOption);
|
|
},
|
|
),
|
|
ValueListenableBuilder(
|
|
valueListenable: patchOptionValue,
|
|
builder: (context, value, child) {
|
|
if (patchOption.required && value == null) {
|
|
return Column(
|
|
crossAxisAlignment: CrossAxisAlignment.start,
|
|
children: [
|
|
const SizedBox(height: 8),
|
|
Text(
|
|
t.patchOptionsView.requiredOption,
|
|
style: TextStyle(
|
|
color: Theme.of(context).colorScheme.error,
|
|
),
|
|
),
|
|
],
|
|
);
|
|
} else {
|
|
return const SizedBox();
|
|
}
|
|
},
|
|
),
|
|
],
|
|
),
|
|
patchOption: patchOption,
|
|
removeOption: (Option option) {
|
|
removeOption(option);
|
|
},
|
|
);
|
|
}
|
|
}
|
|
|
|
class IntStringLongListPatchOption extends StatelessWidget {
|
|
const IntStringLongListPatchOption({
|
|
super.key,
|
|
required this.patchOption,
|
|
required this.removeOption,
|
|
required this.onChanged,
|
|
});
|
|
|
|
final Option patchOption;
|
|
final void Function(Option option) removeOption;
|
|
final void Function(dynamic value, Option option) onChanged;
|
|
|
|
@override
|
|
Widget build(BuildContext context) {
|
|
final List<dynamic> values = List.from(patchOption.value ?? []);
|
|
final ValueNotifier patchOptionValue = ValueNotifier(values);
|
|
final String type = patchOption.valueType;
|
|
|
|
String getKey(dynamic value) {
|
|
if (value != null && patchOption.values != null) {
|
|
final List values = patchOption.values!.entries
|
|
.where((e) => e.value.toString() == value)
|
|
.toList();
|
|
if (values.isNotEmpty) {
|
|
return values.first.key;
|
|
}
|
|
}
|
|
return '';
|
|
}
|
|
|
|
bool isCustomValue() {
|
|
if (values.length == 1 && patchOption.values != null) {
|
|
if (getKey(values[0]) != '') {
|
|
return false;
|
|
}
|
|
}
|
|
return true;
|
|
}
|
|
|
|
bool isTextFieldVisible = isCustomValue();
|
|
|
|
return PatchOption(
|
|
widget: ValueListenableBuilder(
|
|
valueListenable: patchOptionValue,
|
|
builder: (context, value, child) {
|
|
return Column(
|
|
crossAxisAlignment: CrossAxisAlignment.start,
|
|
children: [
|
|
ListView.builder(
|
|
shrinkWrap: true,
|
|
itemCount: value.length,
|
|
physics: const NeverScrollableScrollPhysics(),
|
|
itemBuilder: (BuildContext context, int index) {
|
|
final e = values[index];
|
|
return TextFieldForPatchOption(
|
|
value: e.toString(),
|
|
values: patchOption.values,
|
|
optionType: type,
|
|
selectedKey: value.length > 1 ? '' : getKey(e),
|
|
showDropdown: index == 0,
|
|
onChanged: (newValue) {
|
|
if (newValue is List) {
|
|
values.clear();
|
|
isTextFieldVisible = false;
|
|
values.add(newValue.toString());
|
|
} else {
|
|
isTextFieldVisible = true;
|
|
if (values.length == 1 &&
|
|
values[0].toString().startsWith('[') &&
|
|
type.contains('Array')) {
|
|
values.clear();
|
|
values.addAll(patchOption.value);
|
|
} else {
|
|
values[index] = type == 'StringArray'
|
|
? newValue
|
|
: type == 'IntArray'
|
|
? int.parse(
|
|
newValue.toString().isEmpty
|
|
? '0'
|
|
: newValue.toString(),
|
|
)
|
|
: num.parse(
|
|
newValue.toString().isEmpty
|
|
? '0'
|
|
: newValue.toString(),
|
|
);
|
|
}
|
|
}
|
|
patchOptionValue.value = List.from(values);
|
|
onChanged(values, patchOption);
|
|
},
|
|
removeValue: () {
|
|
patchOptionValue.value = List.from(patchOptionValue.value)
|
|
..removeAt(index);
|
|
values.removeAt(index);
|
|
onChanged(values, patchOption);
|
|
},
|
|
);
|
|
},
|
|
),
|
|
if (isTextFieldVisible) ...[
|
|
const SizedBox(height: 4),
|
|
Align(
|
|
alignment: Alignment.centerLeft,
|
|
child: TextButton(
|
|
onPressed: () {
|
|
if (type == 'StringArray') {
|
|
patchOptionValue.value =
|
|
List.from(patchOptionValue.value)..add('');
|
|
values.add('');
|
|
} else {
|
|
patchOptionValue.value =
|
|
List.from(patchOptionValue.value)..add(0);
|
|
values.add(0);
|
|
}
|
|
onChanged(values, patchOption);
|
|
},
|
|
child: Row(
|
|
mainAxisSize: MainAxisSize.min,
|
|
children: [
|
|
const Icon(Icons.add, size: 20),
|
|
Text(
|
|
t.add,
|
|
style: const TextStyle(
|
|
fontSize: 14,
|
|
fontWeight: FontWeight.w600,
|
|
),
|
|
),
|
|
],
|
|
),
|
|
),
|
|
),
|
|
],
|
|
],
|
|
);
|
|
},
|
|
),
|
|
patchOption: patchOption,
|
|
removeOption: (Option option) {
|
|
removeOption(option);
|
|
},
|
|
);
|
|
}
|
|
}
|
|
|
|
class UnsupportedPatchOption extends StatelessWidget {
|
|
const UnsupportedPatchOption({super.key, required this.patchOption});
|
|
|
|
final Option patchOption;
|
|
|
|
@override
|
|
Widget build(BuildContext context) {
|
|
return PatchOption(
|
|
widget: Align(
|
|
alignment: Alignment.centerLeft,
|
|
child: Padding(
|
|
padding: const EdgeInsets.symmetric(vertical: 8.0),
|
|
child: Text(
|
|
t.patchOptionsView.unsupportedOption,
|
|
style: const TextStyle(
|
|
fontSize: 16,
|
|
),
|
|
),
|
|
),
|
|
),
|
|
patchOption: patchOption,
|
|
removeOption: (_) {},
|
|
);
|
|
}
|
|
}
|
|
|
|
class PatchOption extends StatelessWidget {
|
|
const PatchOption({
|
|
super.key,
|
|
required this.widget,
|
|
required this.patchOption,
|
|
required this.removeOption,
|
|
});
|
|
|
|
final Widget widget;
|
|
final Option patchOption;
|
|
final void Function(Option option) removeOption;
|
|
|
|
@override
|
|
Widget build(BuildContext context) {
|
|
return Padding(
|
|
padding: const EdgeInsets.all(8.0),
|
|
child: CustomCard(
|
|
child: Row(
|
|
children: [
|
|
Expanded(
|
|
child: Column(
|
|
children: [
|
|
Row(
|
|
mainAxisAlignment: MainAxisAlignment.spaceBetween,
|
|
crossAxisAlignment: CrossAxisAlignment.start,
|
|
children: [
|
|
Expanded(
|
|
child: Column(
|
|
crossAxisAlignment: CrossAxisAlignment.start,
|
|
children: [
|
|
Text(
|
|
patchOption.title,
|
|
style: const TextStyle(
|
|
fontSize: 16,
|
|
fontWeight: FontWeight.w600,
|
|
),
|
|
),
|
|
const SizedBox(height: 4),
|
|
Text(
|
|
patchOption.description,
|
|
style: TextStyle(
|
|
fontSize: 14,
|
|
color: Theme.of(context)
|
|
.colorScheme
|
|
.onSecondaryContainer,
|
|
),
|
|
),
|
|
],
|
|
),
|
|
),
|
|
if (!patchOption.required)
|
|
IconButton(
|
|
onPressed: () => removeOption(patchOption),
|
|
icon: const Icon(Icons.delete),
|
|
),
|
|
],
|
|
),
|
|
const SizedBox(height: 4),
|
|
widget,
|
|
],
|
|
),
|
|
),
|
|
],
|
|
),
|
|
),
|
|
);
|
|
}
|
|
}
|
|
|
|
class TextFieldForPatchOption extends StatefulWidget {
|
|
const TextFieldForPatchOption({
|
|
super.key,
|
|
required this.value,
|
|
required this.values,
|
|
this.removeValue,
|
|
required this.onChanged,
|
|
required this.optionType,
|
|
required this.selectedKey,
|
|
this.showDropdown = true,
|
|
});
|
|
|
|
final String? value;
|
|
final Map<String, dynamic>? values;
|
|
final String optionType;
|
|
final String selectedKey;
|
|
final bool showDropdown;
|
|
final void Function()? removeValue;
|
|
final void Function(dynamic value) onChanged;
|
|
|
|
@override
|
|
State<TextFieldForPatchOption> createState() =>
|
|
_TextFieldForPatchOptionState();
|
|
}
|
|
|
|
class _TextFieldForPatchOptionState extends State<TextFieldForPatchOption> {
|
|
final TextEditingController controller = TextEditingController();
|
|
String? selectedKey;
|
|
String? defaultValue;
|
|
|
|
@override
|
|
Widget build(BuildContext context) {
|
|
final bool isStringOption = widget.optionType.contains('String');
|
|
final bool isArrayOption = widget.optionType.contains('Array');
|
|
selectedKey ??= widget.selectedKey;
|
|
controller.text = !isStringOption &&
|
|
isArrayOption &&
|
|
selectedKey == '' &&
|
|
(widget.value != null && widget.value.toString().startsWith('['))
|
|
? ''
|
|
: widget.value ?? '';
|
|
defaultValue ??= controller.text;
|
|
return Column(
|
|
crossAxisAlignment: CrossAxisAlignment.start,
|
|
children: [
|
|
if (widget.showDropdown && (widget.values?.isNotEmpty ?? false))
|
|
DropdownButton<String>(
|
|
style: const TextStyle(
|
|
fontSize: 16,
|
|
),
|
|
borderRadius: BorderRadius.circular(4),
|
|
dropdownColor: Theme.of(context).colorScheme.secondaryContainer,
|
|
isExpanded: true,
|
|
value: selectedKey,
|
|
items: widget.values!.entries
|
|
.map(
|
|
(e) => DropdownMenuItem(
|
|
value: e.key,
|
|
child: RichText(
|
|
text: TextSpan(
|
|
text: e.key,
|
|
style: TextStyle(
|
|
fontSize: 16,
|
|
color: Theme.of(context)
|
|
.colorScheme
|
|
.onSecondaryContainer,
|
|
),
|
|
children: [
|
|
TextSpan(
|
|
text: ' ${e.value}',
|
|
style: TextStyle(
|
|
fontSize: 14,
|
|
color: Theme.of(context)
|
|
.colorScheme
|
|
.onSecondaryContainer
|
|
.withOpacity(0.6),
|
|
),
|
|
),
|
|
],
|
|
),
|
|
),
|
|
),
|
|
)
|
|
.toList()
|
|
..add(
|
|
DropdownMenuItem(
|
|
value: '',
|
|
child: Text(
|
|
t.patchOptionsView.customValue,
|
|
style: const TextStyle(
|
|
fontSize: 16,
|
|
),
|
|
),
|
|
),
|
|
),
|
|
onChanged: (value) {
|
|
if (value == '') {
|
|
controller.text = defaultValue!;
|
|
widget.onChanged(controller.text);
|
|
} else {
|
|
controller.text = widget.values![value].toString();
|
|
widget.onChanged(
|
|
isArrayOption ? widget.values![value] : controller.text,
|
|
);
|
|
}
|
|
setState(() {
|
|
selectedKey = value;
|
|
});
|
|
},
|
|
),
|
|
if (selectedKey == '')
|
|
TextFormField(
|
|
inputFormatters: [
|
|
if (widget.optionType.contains('Int'))
|
|
FilteringTextInputFormatter.allow(RegExp(r'[0-9]')),
|
|
if (widget.optionType.contains('Long'))
|
|
FilteringTextInputFormatter.allow(RegExp(r'^[0-9]*\.?[0-9]*')),
|
|
],
|
|
controller: controller,
|
|
keyboardType:
|
|
isStringOption ? TextInputType.text : TextInputType.number,
|
|
decoration: InputDecoration(
|
|
suffixIcon: PopupMenuButton(
|
|
tooltip: t.patchOptionsView.tooltip,
|
|
itemBuilder: (BuildContext context) {
|
|
return [
|
|
if (isArrayOption)
|
|
PopupMenuItem(
|
|
value: t.remove,
|
|
child: Text(t.remove),
|
|
),
|
|
if (isStringOption) ...[
|
|
PopupMenuItem(
|
|
value: t.patchOptionsView.selectFilePath,
|
|
child: Text(t.patchOptionsView.selectFilePath),
|
|
),
|
|
PopupMenuItem(
|
|
value: t.patchOptionsView.selectFolder,
|
|
child: Text(t.patchOptionsView.selectFolder),
|
|
),
|
|
],
|
|
];
|
|
},
|
|
onSelected: (String selection) async {
|
|
switch (selection) {
|
|
case 'patchOptionsView.selectFilePath':
|
|
final String? result = await FlutterFileDialog.pickFile();
|
|
if (result != null) {
|
|
controller.text = result;
|
|
widget.onChanged(controller.text);
|
|
}
|
|
break;
|
|
case 'patchOptionsView.selectFolder':
|
|
final DirectoryLocation? result =
|
|
await FlutterFileDialog.pickDirectory();
|
|
if (result != null) {
|
|
controller.text = result.toString();
|
|
widget.onChanged(controller.text);
|
|
}
|
|
break;
|
|
case 'remove':
|
|
widget.removeValue!();
|
|
break;
|
|
}
|
|
},
|
|
),
|
|
hintStyle: TextStyle(
|
|
fontSize: 14,
|
|
color: Theme.of(context).colorScheme.onSecondaryContainer,
|
|
),
|
|
),
|
|
onChanged: (String value) {
|
|
widget.onChanged(value);
|
|
},
|
|
),
|
|
],
|
|
);
|
|
}
|
|
}
|