commit 0242aa3b73393cdf7f90766a7e1a149901a721fb Author: ADITYA Date: Thu Jun 29 17:54:41 2023 +0530 . diff --git a/.gitignore b/.gitignore new file mode 100644 index 0000000..aa724b7 --- /dev/null +++ b/.gitignore @@ -0,0 +1,15 @@ +*.iml +.gradle +/local.properties +/.idea/caches +/.idea/libraries +/.idea/modules.xml +/.idea/workspace.xml +/.idea/navEditor.xml +/.idea/assetWizardSettings.xml +.DS_Store +/build +/captures +.externalNativeBuild +.cxx +local.properties diff --git a/.idea/.gitignore b/.idea/.gitignore new file mode 100644 index 0000000..26d3352 --- /dev/null +++ b/.idea/.gitignore @@ -0,0 +1,3 @@ +# Default ignored files +/shelf/ +/workspace.xml diff --git a/.idea/compiler.xml b/.idea/compiler.xml new file mode 100644 index 0000000..fb7f4a8 --- /dev/null +++ b/.idea/compiler.xml @@ -0,0 +1,6 @@ + + + + + + \ No newline at end of file diff --git a/.idea/deploymentTargetDropDown.xml b/.idea/deploymentTargetDropDown.xml new file mode 100644 index 0000000..9fee169 --- /dev/null +++ b/.idea/deploymentTargetDropDown.xml @@ -0,0 +1,17 @@ + + + + + + + + + + + + + + + + + \ No newline at end of file diff --git a/.idea/gradle.xml b/.idea/gradle.xml new file mode 100644 index 0000000..a2d7c21 --- /dev/null +++ b/.idea/gradle.xml @@ -0,0 +1,19 @@ + + + + + + + \ No newline at end of file diff --git a/.idea/misc.xml b/.idea/misc.xml new file mode 100644 index 0000000..bdd9278 --- /dev/null +++ b/.idea/misc.xml @@ -0,0 +1,10 @@ + + + + + + + + + \ No newline at end of file diff --git a/.idea/render.experimental.xml b/.idea/render.experimental.xml new file mode 100644 index 0000000..8ec256a --- /dev/null +++ b/.idea/render.experimental.xml @@ -0,0 +1,6 @@ + + + + + \ No newline at end of file diff --git a/app/.gitignore b/app/.gitignore new file mode 100644 index 0000000..42afabf --- /dev/null +++ b/app/.gitignore @@ -0,0 +1 @@ +/build \ No newline at end of file diff --git a/app/build.gradle b/app/build.gradle new file mode 100644 index 0000000..057625f --- /dev/null +++ b/app/build.gradle @@ -0,0 +1,64 @@ +plugins { + id 'com.android.application' +} + +android { + namespace 'com.ssb.simplitend' + compileSdk 33 + + defaultConfig { + applicationId "com.ssb.simplitend" + minSdk 23 + targetSdk 33 + versionCode 1 + versionName "1.0" + + testInstrumentationRunner "androidx.test.runner.AndroidJUnitRunner" + } + + buildTypes { + release { + minifyEnabled false + proguardFiles getDefaultProguardFile('proguard-android-optimize.txt'), 'proguard-rules.pro' + } + } + compileOptions { + sourceCompatibility JavaVersion.VERSION_1_8 + targetCompatibility JavaVersion.VERSION_1_8 + } + + buildFeatures{ + viewBinding true + } + +} + +dependencies { + + // Navigation component + def nav_version = "2.5.3" + + // Java language implementation + implementation "androidx.navigation:navigation-fragment:$nav_version" + implementation "androidx.navigation:navigation-ui:$nav_version" + + // circle indicator for viewpager + implementation 'me.relex:circleindicator:2.1.6' + + // picasso + implementation 'com.squareup.picasso:picasso:2.8' + + // Glide + implementation 'com.github.bumptech.glide:glide:4.15.1' + + // lottie animations + def lottieVersion = "3.4.0" + implementation "com.airbnb.android:lottie:$lottieVersion" + + implementation 'androidx.appcompat:appcompat:1.6.0' + implementation 'com.google.android.material:material:1.8.0' + implementation 'androidx.constraintlayout:constraintlayout:2.1.4' + testImplementation 'junit:junit:4.13.2' + androidTestImplementation 'androidx.test.ext:junit:1.1.5' + androidTestImplementation 'androidx.test.espresso:espresso-core:3.5.1' +} \ No newline at end of file diff --git a/app/proguard-rules.pro b/app/proguard-rules.pro new file mode 100644 index 0000000..481bb43 --- /dev/null +++ b/app/proguard-rules.pro @@ -0,0 +1,21 @@ +# Add project specific ProGuard rules here. +# You can control the set of applied configuration files using the +# proguardFiles setting in build.gradle. +# +# For more details, see +# http://developer.android.com/guide/developing/tools/proguard.html + +# If your project uses WebView with JS, uncomment the following +# and specify the fully qualified class name to the JavaScript interface +# class: +#-keepclassmembers class fqcn.of.javascript.interface.for.webview { +# public *; +#} + +# Uncomment this to preserve the line number information for +# debugging stack traces. +#-keepattributes SourceFile,LineNumberTable + +# If you keep the line number information, uncomment this to +# hide the original source file name. +#-renamesourcefileattribute SourceFile \ No newline at end of file diff --git a/app/src/androidTest/java/com/ssb/simplitend/ExampleInstrumentedTest.java b/app/src/androidTest/java/com/ssb/simplitend/ExampleInstrumentedTest.java new file mode 100644 index 0000000..22c86a6 --- /dev/null +++ b/app/src/androidTest/java/com/ssb/simplitend/ExampleInstrumentedTest.java @@ -0,0 +1,26 @@ +package com.ssb.simplitend; + +import android.content.Context; + +import androidx.test.platform.app.InstrumentationRegistry; +import androidx.test.ext.junit.runners.AndroidJUnit4; + +import org.junit.Test; +import org.junit.runner.RunWith; + +import static org.junit.Assert.*; + +/** + * Instrumented test, which will execute on an Android device. + * + * @see Testing documentation + */ +@RunWith(AndroidJUnit4.class) +public class ExampleInstrumentedTest { + @Test + public void useAppContext() { + // Context of the app under test. + Context appContext = InstrumentationRegistry.getInstrumentation().getTargetContext(); + assertEquals("com.ssb.simplitend", appContext.getPackageName()); + } +} \ No newline at end of file diff --git a/app/src/main/AndroidManifest.xml b/app/src/main/AndroidManifest.xml new file mode 100644 index 0000000..f7fb86d --- /dev/null +++ b/app/src/main/AndroidManifest.xml @@ -0,0 +1,32 @@ + + + + + + + + + + + + + + + + + + \ No newline at end of file diff --git a/app/src/main/java/com/ssb/simplitend/apputils/AppUtil.java b/app/src/main/java/com/ssb/simplitend/apputils/AppUtil.java new file mode 100644 index 0000000..228b8b4 --- /dev/null +++ b/app/src/main/java/com/ssb/simplitend/apputils/AppUtil.java @@ -0,0 +1,21 @@ +package com.ssb.simplitend.apputils; + +import android.app.Activity; +import android.content.Context; +import android.view.View; +import android.view.inputmethod.InputMethodManager; + +public abstract class AppUtil { + + // closes keyboard + public static void closeKeyboard(Activity activity){ + if (activity != null){ + View view = activity.getCurrentFocus(); + if (view != null) { + InputMethodManager imm = (InputMethodManager)activity.getSystemService(Context.INPUT_METHOD_SERVICE); + imm.hideSoftInputFromWindow(view.getWindowToken(), 0); + } + } + } + +} diff --git a/app/src/main/java/com/ssb/simplitend/userprofile/ProfileProgressFragment.java b/app/src/main/java/com/ssb/simplitend/userprofile/ProfileProgressFragment.java new file mode 100644 index 0000000..a9c53db --- /dev/null +++ b/app/src/main/java/com/ssb/simplitend/userprofile/ProfileProgressFragment.java @@ -0,0 +1,30 @@ +package com.ssb.simplitend.userprofile; + +import android.os.Bundle; +import android.view.LayoutInflater; +import android.view.View; +import android.view.ViewGroup; + +import androidx.annotation.NonNull; +import androidx.annotation.Nullable; +import androidx.fragment.app.Fragment; + +import com.ssb.simplitend.databinding.ProfileProgressFragmentBinding; + +public class ProfileProgressFragment extends Fragment { + + // view binding + protected ProfileProgressFragmentBinding binding; + + public ProfileProgressFragment(){ + // required empty const. + } + + @Nullable + @Override + public View onCreateView(@NonNull LayoutInflater inflater, @Nullable ViewGroup container, @Nullable Bundle savedInstanceState) { + binding = ProfileProgressFragmentBinding.inflate(inflater, container, false); + + return binding.getRoot(); + } +} diff --git a/app/src/main/java/com/ssb/simplitend/welcome/activities/WelcomeActivity.java b/app/src/main/java/com/ssb/simplitend/welcome/activities/WelcomeActivity.java new file mode 100644 index 0000000..aeadd03 --- /dev/null +++ b/app/src/main/java/com/ssb/simplitend/welcome/activities/WelcomeActivity.java @@ -0,0 +1,20 @@ +package com.ssb.simplitend.welcome.activities; + +import androidx.appcompat.app.AppCompatActivity; + +import android.os.Bundle; + +import com.ssb.simplitend.databinding.ActivityWelcomeBinding; + +public class WelcomeActivity extends AppCompatActivity { + + // View binding + protected ActivityWelcomeBinding binding; + + @Override + protected void onCreate(Bundle savedInstanceState) { + super.onCreate(savedInstanceState); + binding = ActivityWelcomeBinding.inflate(getLayoutInflater()); + setContentView(binding.getRoot()); + } +} \ No newline at end of file diff --git a/app/src/main/java/com/ssb/simplitend/welcome/fragments/ChooseRoleFragment.java b/app/src/main/java/com/ssb/simplitend/welcome/fragments/ChooseRoleFragment.java new file mode 100644 index 0000000..075ce56 --- /dev/null +++ b/app/src/main/java/com/ssb/simplitend/welcome/fragments/ChooseRoleFragment.java @@ -0,0 +1,88 @@ +package com.ssb.simplitend.welcome.fragments; + +import android.os.Bundle; +import android.view.LayoutInflater; +import android.view.View; +import android.view.ViewGroup; + +import androidx.annotation.NonNull; +import androidx.annotation.Nullable; +import androidx.fragment.app.Fragment; +import androidx.navigation.Navigation; + +import com.ssb.simplitend.R; +import com.ssb.simplitend.databinding.ChooseRoleFragmentBinding; + +public class ChooseRoleFragment extends Fragment { + + protected ChooseRoleFragmentBinding binding; + + private static final String SELECTED_ROLE_KEY = "selected_role"; + private static final int SENIOR = 1; + private static final int CAREGIVER = 2; + + private int selected_role = SENIOR; + + public ChooseRoleFragment(){ + // required empty fragment + } + + @Nullable + @Override + public View onCreateView(@NonNull LayoutInflater inflater, @Nullable ViewGroup container, @Nullable Bundle savedInstanceState) { + binding = ChooseRoleFragmentBinding.inflate(inflater, container, false); + + initViews(savedInstanceState); + + clickEvents(); + + return binding.getRoot(); + } + + // registers all click listeners + private void clickEvents() { + + binding.seniorRole.setOnClickListener(v -> { + makeRoleSelection(SENIOR); + Navigation.findNavController(v).navigate(R.id.action_chooseRoleFragment_to_signInSignUpFragment); + }); + + binding.caregiverRole.setOnClickListener(v -> makeRoleSelection(CAREGIVER)); + + } + + // initialize views + private void initViews(Bundle savedInstanceState) { + // checking if any previous instance existed + if (savedInstanceState != null){ + // previously instance existed + // thus, retrieving selected_role chosen + + selected_role = savedInstanceState.getInt(SELECTED_ROLE_KEY, SENIOR); + } + + // making the role selection + makeRoleSelection(selected_role); + } + + @Override + public void onSaveInstanceState(@NonNull Bundle outState) { + super.onSaveInstanceState(outState); + outState.putInt(SELECTED_ROLE_KEY, selected_role); + } + + /* + makes the check for each role visible or invisible according to the selected role + */ + private void makeRoleSelection(int selectedRole){ + selected_role = selectedRole; + + if (selectedRole == SENIOR){ + binding.seniorCheck.setVisibility(View.VISIBLE); + binding.caregiverCheck.setVisibility(View.GONE); + }else{ + binding.caregiverCheck.setVisibility(View.VISIBLE); + binding.seniorCheck.setVisibility(View.GONE); + } + } +} diff --git a/app/src/main/java/com/ssb/simplitend/welcome/fragments/OnBoardPagerAdapter.java b/app/src/main/java/com/ssb/simplitend/welcome/fragments/OnBoardPagerAdapter.java new file mode 100644 index 0000000..98ae521 --- /dev/null +++ b/app/src/main/java/com/ssb/simplitend/welcome/fragments/OnBoardPagerAdapter.java @@ -0,0 +1,37 @@ +package com.ssb.simplitend.welcome.fragments; + +import androidx.annotation.NonNull; +import androidx.fragment.app.Fragment; +import androidx.fragment.app.FragmentManager; +import androidx.lifecycle.Lifecycle; +import androidx.viewpager2.adapter.FragmentStateAdapter; + +import com.ssb.simplitend.welcome.fragments.onboardfragments.OnBoardOne; +import com.ssb.simplitend.welcome.fragments.onboardfragments.OnBoardThree; +import com.ssb.simplitend.welcome.fragments.onboardfragments.OnBoardTwo; + +public class OnBoardPagerAdapter extends FragmentStateAdapter { + + public OnBoardPagerAdapter(@NonNull FragmentManager fragmentManager, @NonNull Lifecycle lifecycle) { + super(fragmentManager, lifecycle); + } + + @NonNull + @Override + public Fragment createFragment(int position) { + switch (position){ + case 2: + return new OnBoardThree(); + case 1: + return new OnBoardTwo(); + default: + return new OnBoardOne(); + } + } + + @Override + public int getItemCount() { + return 3; + } + +} diff --git a/app/src/main/java/com/ssb/simplitend/welcome/fragments/SignInFragment.java b/app/src/main/java/com/ssb/simplitend/welcome/fragments/SignInFragment.java new file mode 100644 index 0000000..4125ed7 --- /dev/null +++ b/app/src/main/java/com/ssb/simplitend/welcome/fragments/SignInFragment.java @@ -0,0 +1,41 @@ +package com.ssb.simplitend.welcome.fragments; + +import android.os.Bundle; +import android.view.LayoutInflater; +import android.view.View; +import android.view.ViewGroup; + +import androidx.annotation.NonNull; +import androidx.annotation.Nullable; +import androidx.fragment.app.Fragment; +import androidx.navigation.Navigation; + +import com.ssb.simplitend.R; +import com.ssb.simplitend.databinding.SignInFragmentBinding; + +public class SignInFragment extends Fragment { + + // view binding + protected SignInFragmentBinding binding; + + public SignInFragment(){ + // required empty constructor + } + + @Nullable + @Override + public View onCreateView(@NonNull LayoutInflater inflater, @Nullable ViewGroup container, @Nullable Bundle savedInstanceState) { + binding = SignInFragmentBinding.inflate(inflater, container, false); + + clickEvents(); + + return binding.getRoot(); + } + + private void clickEvents() { + + binding.forgotPin.setOnClickListener(v -> + Navigation.findNavController(v).navigate(R.id.action_signInFragment_to_forgotPinFragment)); + + } +} diff --git a/app/src/main/java/com/ssb/simplitend/welcome/fragments/SignInSignUpFragment.java b/app/src/main/java/com/ssb/simplitend/welcome/fragments/SignInSignUpFragment.java new file mode 100644 index 0000000..bdb51c8 --- /dev/null +++ b/app/src/main/java/com/ssb/simplitend/welcome/fragments/SignInSignUpFragment.java @@ -0,0 +1,58 @@ +package com.ssb.simplitend.welcome.fragments; + +import android.os.Bundle; +import android.view.LayoutInflater; +import android.view.View; +import android.view.ViewGroup; + +import androidx.annotation.NonNull; +import androidx.annotation.Nullable; +import androidx.fragment.app.Fragment; +import androidx.navigation.Navigation; + +import com.ssb.simplitend.R; +import com.ssb.simplitend.databinding.SignInUpFragmentBinding; + +public class SignInSignUpFragment extends Fragment { + + // view binding + protected SignInUpFragmentBinding binding; + + protected OnBoardPagerAdapter onBoardPagerAdapter; + + public SignInSignUpFragment(){ + // required empty constructor + } + + @Nullable + @Override + public View onCreateView(@NonNull LayoutInflater inflater, @Nullable ViewGroup container, @Nullable Bundle savedInstanceState) { + binding = SignInUpFragmentBinding.inflate(inflater, container, false); + + initViews(); + + clickEvents(); + + return binding.getRoot(); + } + + private void clickEvents() { + + // log in + binding.login.setOnClickListener(v -> + Navigation.findNavController(v).navigate(R.id.action_signInSignUpFragment_to_signInFragment) + ); + + // register + binding.register.setOnClickListener(v -> + Navigation.findNavController(v).navigate(R.id.action_signInSignUpFragment_to_howToSetUpFragment) + ); + + } + + private void initViews() { + onBoardPagerAdapter = new OnBoardPagerAdapter(getChildFragmentManager(), getLifecycle()); + binding.viewPager.setAdapter(onBoardPagerAdapter); + binding.circleIndicator.setViewPager(binding.viewPager); + } +} diff --git a/app/src/main/java/com/ssb/simplitend/welcome/fragments/WelcomeFragment.java b/app/src/main/java/com/ssb/simplitend/welcome/fragments/WelcomeFragment.java new file mode 100644 index 0000000..406249d --- /dev/null +++ b/app/src/main/java/com/ssb/simplitend/welcome/fragments/WelcomeFragment.java @@ -0,0 +1,49 @@ +package com.ssb.simplitend.welcome.fragments; + +import android.os.Bundle; +import android.view.LayoutInflater; +import android.view.View; +import android.view.ViewGroup; + +import androidx.annotation.NonNull; +import androidx.annotation.Nullable; +import androidx.fragment.app.Fragment; +import androidx.navigation.Navigation; + +import com.ssb.simplitend.R; +import com.ssb.simplitend.databinding.WelcomeFragmentBinding; + +public class WelcomeFragment extends Fragment { + + // view binding + protected WelcomeFragmentBinding binding; + + public WelcomeFragment(){ + // required empty const. + } + + @Nullable + @Override + public View onCreateView(@NonNull LayoutInflater inflater, @Nullable ViewGroup container, @Nullable Bundle savedInstanceState) { + binding = WelcomeFragmentBinding.inflate(inflater, container, false); + + initViews(savedInstanceState); + + clickEvents(); + + return binding.getRoot(); + } + + // Initialize views + private void initViews(Bundle savedInstanceState) { + } + + // Register click events + private void clickEvents(){ + binding.nextBtn.setOnClickListener(v -> + Navigation.findNavController(v) + .navigate(R.id.action_welcomeFragment_to_chooseRoleFragment) + ); + } + +} diff --git a/app/src/main/java/com/ssb/simplitend/welcome/fragments/contacts/AddContactFragment.java b/app/src/main/java/com/ssb/simplitend/welcome/fragments/contacts/AddContactFragment.java new file mode 100644 index 0000000..35e15e8 --- /dev/null +++ b/app/src/main/java/com/ssb/simplitend/welcome/fragments/contacts/AddContactFragment.java @@ -0,0 +1,50 @@ +package com.ssb.simplitend.welcome.fragments.contacts; + +import android.os.Bundle; +import android.view.LayoutInflater; +import android.view.View; +import android.view.ViewGroup; + +import androidx.annotation.NonNull; +import androidx.annotation.Nullable; +import androidx.fragment.app.Fragment; +import androidx.navigation.Navigation; + +import com.ssb.simplitend.R; +import com.ssb.simplitend.databinding.AddContactFragmentBinding; + +public class AddContactFragment extends Fragment { + + // view binding + protected AddContactFragmentBinding binding; + + public AddContactFragment(){ + // required empty const. + } + + @Nullable + @Override + public View onCreateView(@NonNull LayoutInflater inflater, @Nullable ViewGroup container, @Nullable Bundle savedInstanceState) { + binding = AddContactFragmentBinding.inflate(inflater, container, false); + + clickEvents(); + + return binding.getRoot(); + } + + private void clickEvents() { + + binding.static1.setOnClickListener(v -> + Navigation.findNavController(v).navigate(R.id.action_addContactFragment_to_contactInfoFragment) + ); + + binding.static2.setOnClickListener(v -> + Navigation.findNavController(v).navigate(R.id.action_addContactFragment_to_contactListFragment) + ); + + binding.nextBtn.setOnClickListener(v -> + Navigation.findNavController(v).navigate(R.id.action_addContactFragment_to_profileProgressFragment) + ); + + } +} diff --git a/app/src/main/java/com/ssb/simplitend/welcome/fragments/contacts/ContactInfoFragment.java b/app/src/main/java/com/ssb/simplitend/welcome/fragments/contacts/ContactInfoFragment.java new file mode 100644 index 0000000..3411c7f --- /dev/null +++ b/app/src/main/java/com/ssb/simplitend/welcome/fragments/contacts/ContactInfoFragment.java @@ -0,0 +1,30 @@ +package com.ssb.simplitend.welcome.fragments.contacts; + +import android.os.Bundle; +import android.view.LayoutInflater; +import android.view.View; +import android.view.ViewGroup; + +import androidx.annotation.NonNull; +import androidx.annotation.Nullable; +import androidx.fragment.app.Fragment; + +import com.ssb.simplitend.databinding.ContactInfoFragmentBinding; + +public class ContactInfoFragment extends Fragment { + + // view binding + protected ContactInfoFragmentBinding binding; + + public ContactInfoFragment(){ + // required empty const. + } + + @Nullable + @Override + public View onCreateView(@NonNull LayoutInflater inflater, @Nullable ViewGroup container, @Nullable Bundle savedInstanceState) { + binding = ContactInfoFragmentBinding.inflate(inflater, container, false); + + return binding.getRoot(); + } +} diff --git a/app/src/main/java/com/ssb/simplitend/welcome/fragments/contacts/ContactListAdapter.java b/app/src/main/java/com/ssb/simplitend/welcome/fragments/contacts/ContactListAdapter.java new file mode 100644 index 0000000..3206778 --- /dev/null +++ b/app/src/main/java/com/ssb/simplitend/welcome/fragments/contacts/ContactListAdapter.java @@ -0,0 +1,81 @@ +package com.ssb.simplitend.welcome.fragments.contacts; + +import android.view.LayoutInflater; +import android.view.ViewGroup; + +import androidx.annotation.NonNull; +import androidx.recyclerview.widget.DiffUtil; +import androidx.recyclerview.widget.ListAdapter; +import androidx.recyclerview.widget.RecyclerView; + +import com.ssb.simplitend.databinding.ContactViewHolderBinding; +import com.ssb.simplitend.welcome.fragments.contacts.mvvm.Contact; + +public class ContactListAdapter extends ListAdapter { + + private OnContactClickListener contactClickListener; + + private static final DiffUtil.ItemCallback DIFF_UTIL = new DiffUtil.ItemCallback() { + @Override + public boolean areItemsTheSame(@NonNull Contact oldItem, @NonNull Contact newItem) { + return oldItem.name.equals(newItem.name); + } + + @Override + public boolean areContentsTheSame(@NonNull Contact oldItem, @NonNull Contact newItem) { + return oldItem.equals(newItem); + } + }; + + public ContactListAdapter(){ + super(DIFF_UTIL); + } + + @NonNull + @Override + public ContactViewHolder onCreateViewHolder(@NonNull ViewGroup parent, int viewType) { + ContactViewHolderBinding binding = ContactViewHolderBinding.inflate(LayoutInflater.from(parent.getContext())); + return new ContactViewHolder(binding); + } + + @Override + public void onBindViewHolder(@NonNull ContactViewHolder holder, int position) { + holder.setData(getItem(position)); + + holder.binding.getRoot().setOnClickListener(v -> { + if (contactClickListener != null){ + contactClickListener.onClick(getItem(position)); + } + }); + } + + public void setContactClickListener(OnContactClickListener contactClickListener) { + this.contactClickListener = contactClickListener; + } + + public static class ContactViewHolder extends RecyclerView.ViewHolder{ + + private final ContactViewHolderBinding binding; + + public ContactViewHolder(ContactViewHolderBinding binding){ + super(binding.getRoot()); + this.binding = binding; + } + + public void setData(Contact contact){ + binding.name.setText(contact.name); + + // static + binding.initial.setText(contact.name.substring(0, 1).toUpperCase()); + + } + + } + + @FunctionalInterface + public interface OnContactClickListener{ + + void onClick(Contact contact); + } + +} diff --git a/app/src/main/java/com/ssb/simplitend/welcome/fragments/contacts/ContactListFragment.java b/app/src/main/java/com/ssb/simplitend/welcome/fragments/contacts/ContactListFragment.java new file mode 100644 index 0000000..d3ea315 --- /dev/null +++ b/app/src/main/java/com/ssb/simplitend/welcome/fragments/contacts/ContactListFragment.java @@ -0,0 +1,119 @@ +package com.ssb.simplitend.welcome.fragments.contacts; + +import static com.ssb.simplitend.welcome.fragments.contacts.CreateContactFragment.CONTACT_KEY; +import static com.ssb.simplitend.welcome.fragments.contacts.CreateContactFragment.TO_EDIT_KEY; + +import android.Manifest; +import android.content.pm.PackageManager; +import android.os.Bundle; +import android.util.Log; +import android.view.LayoutInflater; +import android.view.View; +import android.view.ViewGroup; +import android.widget.Toast; + +import androidx.activity.result.ActivityResultLauncher; +import androidx.activity.result.contract.ActivityResultContracts; +import androidx.annotation.NonNull; +import androidx.annotation.Nullable; +import androidx.fragment.app.Fragment; +import androidx.lifecycle.ViewModelProvider; +import androidx.navigation.Navigation; +import androidx.recyclerview.widget.LinearLayoutManager; + +import com.ssb.simplitend.R; +import com.ssb.simplitend.databinding.ContactListFragmentBinding; +import com.ssb.simplitend.welcome.fragments.contacts.mvvm.Contact; +import com.ssb.simplitend.welcome.fragments.contacts.mvvm.ContactViewModel; + +import java.util.ArrayList; + +public class ContactListFragment extends Fragment { + + private static final String TAG = "aditya"; + + // view binding + protected ContactListFragmentBinding binding; + + protected ContactListAdapter contactListAdapter; + + protected ContactViewModel contactViewModel; + + protected ActivityResultLauncher permissionLauncher; + + public ContactListFragment() { + // required empty const. + } + + @Nullable + @Override + public View onCreateView(@NonNull LayoutInflater inflater, @Nullable ViewGroup container, @Nullable Bundle savedInstanceState) { + binding = ContactListFragmentBinding.inflate(inflater, container, false); + + initializeViews(); + + clickEvents(); + + return binding.getRoot(); + } + + private void clickEvents() { + + binding.backBtn.setOnClickListener(v -> Navigation.findNavController(v).popBackStack()); + + binding.createContact.setOnClickListener(v -> + { + Bundle arguments = new Bundle(); + arguments.putBoolean(TO_EDIT_KEY, false); + Navigation.findNavController(v).navigate(R.id.action_contactListFragment_to_createContactFragment, arguments); + } + ); + + contactListAdapter.setContactClickListener(contact -> + { + Bundle bundle = new Bundle(); + bundle.putBoolean(TO_EDIT_KEY, true); + bundle.putSerializable(CONTACT_KEY, contact); + Navigation.findNavController(binding.getRoot()).navigate(R.id.action_contactListFragment_to_createContactFragment, bundle); + } + ); + + } + + private void initializeViews() { + // initiating recycler view for contact list + contactListAdapter = new ContactListAdapter(); + binding.contactRv.setLayoutManager(new LinearLayoutManager(requireContext())); + binding.contactRv.setAdapter(contactListAdapter); + + permissionLauncher = registerForActivityResult(new ActivityResultContracts.RequestPermission(), + granted -> { + if (granted) { + // user granted the READ_CONTACT permission + loadContacts(); + } else { + // user denied the permission + // TODO: 28-06-2023 + } + } + ); + + loadContacts(); + + } + + /* + loads user's local contacts + */ + private void loadContacts() { + if (requireActivity().checkSelfPermission(Manifest.permission.READ_CONTACTS) != PackageManager.PERMISSION_GRANTED) { + permissionLauncher.launch(Manifest.permission.READ_CONTACTS); + return; + } + + contactViewModel = new ViewModelProvider(this).get(ContactViewModel.class); + Log.d(TAG, "initializeViews: viewmodel " + contactViewModel); + + contactListAdapter.submitList(contactViewModel.getContactList()); + } +} diff --git a/app/src/main/java/com/ssb/simplitend/welcome/fragments/contacts/CreateContactFragment.java b/app/src/main/java/com/ssb/simplitend/welcome/fragments/contacts/CreateContactFragment.java new file mode 100644 index 0000000..5b86690 --- /dev/null +++ b/app/src/main/java/com/ssb/simplitend/welcome/fragments/contacts/CreateContactFragment.java @@ -0,0 +1,204 @@ +package com.ssb.simplitend.welcome.fragments.contacts; + +import android.animation.Animator; +import android.graphics.drawable.Drawable; +import android.os.Bundle; +import android.os.Handler; +import android.util.Log; +import android.view.LayoutInflater; +import android.view.View; +import android.view.ViewGroup; +import android.widget.Toast; + +import androidx.annotation.NonNull; +import androidx.annotation.Nullable; +import androidx.fragment.app.Fragment; +import androidx.navigation.Navigation; +import androidx.vectordrawable.graphics.drawable.Animatable2Compat; + +import com.bumptech.glide.Glide; +import com.bumptech.glide.load.DataSource; +import com.bumptech.glide.load.engine.GlideException; +import com.bumptech.glide.load.resource.gif.GifDrawable; +import com.bumptech.glide.request.RequestListener; +import com.bumptech.glide.request.target.Target; +import com.google.android.material.bottomsheet.BottomSheetDialog; +import com.ssb.simplitend.R; +import com.ssb.simplitend.databinding.CreateEditContactFragmentBinding; +import com.ssb.simplitend.databinding.DecisionBottomsheetBinding; +import com.ssb.simplitend.databinding.DoneBottomsheetBinding; +import com.ssb.simplitend.welcome.fragments.contacts.mvvm.Contact; + +public class CreateContactFragment extends Fragment { + + // view binding + protected CreateEditContactFragmentBinding binding; + + // arguments keys + public static final String TO_EDIT_KEY = "to_edit"; + public static final String CONTACT_KEY = "contact_key"; + + // flag if current instance is to edit or create contact + boolean to_edit; + + public CreateContactFragment() { + // required empty const. + } + + @Nullable + @Override + public View onCreateView(@NonNull LayoutInflater inflater, @Nullable ViewGroup container, @Nullable Bundle savedInstanceState) { + binding = CreateEditContactFragmentBinding.inflate(inflater, container, false); + + initializeViews(); + + clickEvents(); + + return binding.getRoot(); + } + + private void clickEvents() { + + binding.nextBtn.setOnClickListener(v -> { + + if (to_edit){ + // editing existing contact + showSaveEditDecision(); + }else { + // saving new contact + gotoAddContactFragment(); + } + + }); + + } + + private void showSaveEditDecision() { + + DecisionBottomsheetBinding binding = DecisionBottomsheetBinding.inflate(getLayoutInflater()); + + BottomSheetDialog bsd = new BottomSheetDialog(requireContext(), R.style.BottomSheetDialog); + bsd.setContentView(binding.getRoot()); + + binding.text.setText(getString(R.string.make_changes)); + + binding.positiveBtn.setText(getString(R.string.yes)); + binding.negativeBtn.setText(getString(R.string.no)); + + binding.negativeBtn.setOnClickListener(v -> bsd.dismiss()); + + binding.positiveBtn.setOnClickListener(v -> { + bsd.dismiss(); + showDoneBottomSheet(); + }); + + bsd.show(); + + } + + private void showDoneBottomSheet() { + DoneBottomsheetBinding binding = DoneBottomsheetBinding.inflate(getLayoutInflater()); + + BottomSheetDialog bsd = new BottomSheetDialog(requireContext(), R.style.BottomSheetDialog); + bsd.setContentView(binding.getRoot()); + bsd.setCancelable(false); + + binding.text.setText(getString(R.string.changes_successful)); + + binding.anim.addAnimatorListener(new Animator.AnimatorListener() { + @Override + public void onAnimationStart(@NonNull Animator animation) { + + } + + @Override + public void onAnimationEnd(@NonNull Animator animation) { + bsd.dismiss(); + gotoAddContactFragment(); + } + + @Override + public void onAnimationCancel(@NonNull Animator animation) { + + } + + @Override + public void onAnimationRepeat(@NonNull Animator animation) { + } + }); + + bsd.show(); + + } + + private void gotoAddContactFragment(){ + Navigation.findNavController(binding.getRoot()) + .navigate(R.id.action_createContactFragment_to_addContactFragment); + } + + private void showSOSDecision() { + + DecisionBottomsheetBinding binding = DecisionBottomsheetBinding.inflate(getLayoutInflater()); + + BottomSheetDialog bsd = new BottomSheetDialog(requireContext(), R.style.BottomSheetDialog); + bsd.setContentView(binding.getRoot()); + + binding.text.setText(getString(R.string.make_sos)); + + binding.positiveBtn.setText(getString(R.string.yes)); + binding.negativeBtn.setText(getString(R.string.no)); + + binding.negativeBtn.setOnClickListener(v -> { + bsd.dismiss(); + this.binding.sosCheck.setChecked(false); + }); + + binding.positiveBtn.setOnClickListener(v -> { + bsd.dismiss(); + this.binding.sosCheck.setChecked(true); + }); + + bsd.show(); + + } + + private void initializeViews() { + Bundle bundle = getArguments(); + + if (bundle != null){ + to_edit = bundle.getBoolean(TO_EDIT_KEY, false); + + if (to_edit){ + + setLayoutDetails(getString(R.string.edit_contact), getString(R.string.change_photo), getString(R.string.save)); + + Contact contact = (Contact) bundle.getSerializable(CONTACT_KEY); + setDetails(contact); + + }else{ + setLayoutDetails(getString(R.string.create_contact), getString(R.string.add_photo), getString(R.string.create_contact)); + } + } + + binding.sosCheck.setOnCheckedChangeListener((buttonView, isChecked) -> { + if (isChecked){ + showSOSDecision(); + } + }); + + } + + private void setDetails(Contact contact) { + binding.name.setText(contact.name); + binding.phoneNumber.setText(contact.phoneNumber); + binding.email.setText(contact.email); + binding.relationship.setText(contact.relationship); + } + + public void setLayoutDetails(String title, String photo_title, String btn_txt){ + binding.title.setText(title); + binding.photoTv.setText(photo_title); + binding.nextBtn.setText(btn_txt); + } + +} diff --git a/app/src/main/java/com/ssb/simplitend/welcome/fragments/contacts/mvvm/Contact.java b/app/src/main/java/com/ssb/simplitend/welcome/fragments/contacts/mvvm/Contact.java new file mode 100644 index 0000000..452800c --- /dev/null +++ b/app/src/main/java/com/ssb/simplitend/welcome/fragments/contacts/mvvm/Contact.java @@ -0,0 +1,44 @@ +package com.ssb.simplitend.welcome.fragments.contacts.mvvm; + +import java.io.Serializable; +import java.util.Objects; + +public class Contact implements Serializable { + + public String name, imageUri, phoneNumber, relationship, email; + + public Contact(){} + + public Contact(String name){ + this.name = name; + } + + public Contact(String name, String phoneNumber){ + this.name = name; + this.phoneNumber = phoneNumber; + } + + @Override + public boolean equals(Object o) { + if (this == o) return true; + if (o == null || getClass() != o.getClass()) return false; + Contact contact = (Contact) o; + return name.equals(contact.name) && Objects.equals(imageUri, contact.imageUri) && phoneNumber.equals(contact.phoneNumber) && Objects.equals(relationship, contact.relationship) && Objects.equals(email, contact.email); + } + + @Override + public int hashCode() { + return Objects.hash(name, imageUri, phoneNumber, relationship, email); + } + + @Override + public String toString() { + return "Contact{" + + "name='" + name + '\'' + + ", imageUri='" + imageUri + '\'' + + ", phoneNumber='" + phoneNumber + '\'' + + ", relationship='" + relationship + '\'' + + ", email='" + email + '\'' + + '}'; + } +} diff --git a/app/src/main/java/com/ssb/simplitend/welcome/fragments/contacts/mvvm/ContactViewModel.java b/app/src/main/java/com/ssb/simplitend/welcome/fragments/contacts/mvvm/ContactViewModel.java new file mode 100644 index 0000000..69d5273 --- /dev/null +++ b/app/src/main/java/com/ssb/simplitend/welcome/fragments/contacts/mvvm/ContactViewModel.java @@ -0,0 +1,29 @@ +package com.ssb.simplitend.welcome.fragments.contacts.mvvm; + +import android.app.Application; +import android.content.Context; + +import androidx.lifecycle.AndroidViewModel; +import androidx.lifecycle.ViewModel; + +import java.util.ArrayList; + +public class ContactViewModel extends AndroidViewModel { + + private final ArrayList contactList; + private final UserContactRepository contactRepository; + + public ContactViewModel(Application application){ + super(application); + this.contactRepository = new UserContactRepository(); + this.contactList = this.contactRepository.getContactList(application.getApplicationContext()); + } + + public ArrayList getContactList() { + return contactList; + } + + public UserContactRepository getContactRepository() { + return contactRepository; + } +} diff --git a/app/src/main/java/com/ssb/simplitend/welcome/fragments/contacts/mvvm/UserContactRepository.java b/app/src/main/java/com/ssb/simplitend/welcome/fragments/contacts/mvvm/UserContactRepository.java new file mode 100644 index 0000000..4050852 --- /dev/null +++ b/app/src/main/java/com/ssb/simplitend/welcome/fragments/contacts/mvvm/UserContactRepository.java @@ -0,0 +1,63 @@ +package com.ssb.simplitend.welcome.fragments.contacts.mvvm; + +import android.content.ContentResolver; +import android.content.Context; +import android.database.Cursor; +import android.provider.ContactsContract; +import android.util.Log; + +import com.ssb.simplitend.welcome.fragments.contacts.mvvm.Contact; + +import java.util.ArrayList; +import java.util.HashSet; + +public class UserContactRepository { + + private static final String[] PROJECTION = new String[]{ + ContactsContract.CommonDataKinds.Phone.CONTACT_ID, + ContactsContract.Contacts.DISPLAY_NAME, + ContactsContract.CommonDataKinds.Phone.NUMBER + }; + + public UserContactRepository(){} + + public ArrayList getContactList(Context context) { + final ArrayList contactList = new ArrayList<>(); + + ContentResolver cr = context.getContentResolver(); + + Cursor cursor = cr.query(ContactsContract.CommonDataKinds.Phone.CONTENT_URI, PROJECTION, null, null, ContactsContract.CommonDataKinds.Phone.DISPLAY_NAME + " ASC"); + + if (cursor != null) { + + // To avoid duplicate phone numbers + HashSet mobileNoSet = new HashSet(); + + try { + final int nameIndex = cursor.getColumnIndex(ContactsContract.Contacts.DISPLAY_NAME); + final int numberIndex = cursor.getColumnIndex(ContactsContract.CommonDataKinds.Phone.NUMBER); + + Log.d("aditya", "getContactList: " + cursor.getColumnCount()); + + String name, number, photoUri; + while (cursor.moveToNext()) { + name = cursor.getString(nameIndex); + number = cursor.getString(numberIndex); + + + // avoiding duplicate phone number + number = number.replace(" ", ""); + if (!mobileNoSet.contains(number)) { + contactList.add(new Contact(name, number)); + mobileNoSet.add(number); + } + } + } finally { + cursor.close(); + } + } + + return contactList; + } + +} diff --git a/app/src/main/java/com/ssb/simplitend/welcome/fragments/forgotpin/ChangePinFragment.java b/app/src/main/java/com/ssb/simplitend/welcome/fragments/forgotpin/ChangePinFragment.java new file mode 100644 index 0000000..81b6b8f --- /dev/null +++ b/app/src/main/java/com/ssb/simplitend/welcome/fragments/forgotpin/ChangePinFragment.java @@ -0,0 +1,40 @@ +package com.ssb.simplitend.welcome.fragments.forgotpin; + +import android.os.Bundle; +import android.view.LayoutInflater; +import android.view.View; +import android.view.ViewGroup; + +import androidx.annotation.NonNull; +import androidx.annotation.Nullable; +import androidx.fragment.app.Fragment; +import androidx.navigation.Navigation; + +import com.ssb.simplitend.databinding.ChangePinFragmentBinding; + +public class ChangePinFragment extends Fragment { + + // view binding + protected ChangePinFragmentBinding binding; + + public ChangePinFragment(){ + // required empty const. + } + + @Nullable + @Override + public View onCreateView(@NonNull LayoutInflater inflater, @Nullable ViewGroup container, @Nullable Bundle savedInstanceState) { + binding = ChangePinFragmentBinding.inflate(inflater, container, false); + + clickEvents(); + + return binding.getRoot(); + } + + private void clickEvents() { + + binding.backBtn.setOnClickListener(v -> Navigation.findNavController(v).popBackStack()); + + } + +} diff --git a/app/src/main/java/com/ssb/simplitend/welcome/fragments/forgotpin/CheckMailFragment.java b/app/src/main/java/com/ssb/simplitend/welcome/fragments/forgotpin/CheckMailFragment.java new file mode 100644 index 0000000..d82252a --- /dev/null +++ b/app/src/main/java/com/ssb/simplitend/welcome/fragments/forgotpin/CheckMailFragment.java @@ -0,0 +1,156 @@ +package com.ssb.simplitend.welcome.fragments.forgotpin; + +import android.os.Bundle; +import android.text.Editable; +import android.text.TextWatcher; +import android.view.LayoutInflater; +import android.view.View; +import android.view.ViewGroup; + +import androidx.annotation.NonNull; +import androidx.annotation.Nullable; +import androidx.fragment.app.Fragment; +import androidx.navigation.Navigation; + +import com.ssb.simplitend.R; +import com.ssb.simplitend.apputils.AppUtil; +import com.ssb.simplitend.databinding.CheckMailFragmentBinding; + +public class CheckMailFragment extends Fragment { + + // view binding + protected CheckMailFragmentBinding binding; + + public CheckMailFragment() { + // required empty const. + } + + @Nullable + @Override + public View onCreateView(@NonNull LayoutInflater inflater, @Nullable ViewGroup container, @Nullable Bundle savedInstanceState) { + binding = CheckMailFragmentBinding.inflate(inflater, container, false); + + initViews(); + + clickEvents(); + + return binding.getRoot(); + } + + private void initViews() { + + initOTPBoxes(); + + } + + /* + setting text change listener for every edit text for otp + */ + private void initOTPBoxes() { + + binding.otp1.addTextChangedListener(new TextWatcher() { + @Override + public void beforeTextChanged(CharSequence s, int start, int count, int after) { + + } + + @Override + public void onTextChanged(CharSequence s, int start, int before, int count) { + + } + + @Override + public void afterTextChanged(Editable s) { + if (!s.toString().trim().isEmpty()) { + binding.otp2.requestFocus(); + } + + // check if all otp boxes are filled + + } + }); + + binding.otp2.addTextChangedListener(new TextWatcher() { + @Override + public void beforeTextChanged(CharSequence s, int start, int count, int after) { + + } + + @Override + public void onTextChanged(CharSequence s, int start, int before, int count) { + + } + + @Override + public void afterTextChanged(Editable s) { + if (!s.toString().trim().isEmpty()) { + binding.otp3.requestFocus(); + } else { + binding.otp1.requestFocus(); + } + + // check if all otp boxes are filled + + } + }); + + binding.otp3.addTextChangedListener(new TextWatcher() { + @Override + public void beforeTextChanged(CharSequence s, int start, int count, int after) { + + } + + @Override + public void onTextChanged(CharSequence s, int start, int before, int count) { + + } + + @Override + public void afterTextChanged(Editable s) { + if (!s.toString().trim().isEmpty()) { + binding.otp4.requestFocus(); + } else { + binding.otp2.requestFocus(); + } + + // check if all otp boxes are filled + + } + }); + + binding.otp4.addTextChangedListener(new TextWatcher() { + @Override + public void beforeTextChanged(CharSequence s, int start, int count, int after) { + + } + + @Override + public void onTextChanged(CharSequence s, int start, int before, int count) { + + } + + @Override + public void afterTextChanged(Editable s) { + if (!s.toString().trim().isEmpty()) { + // last otp inserted + AppUtil.closeKeyboard(getActivity()); + } else { + binding.otp3.requestFocus(); + } + + // check if all otp boxes are filled + + } + }); + + } + + private void clickEvents() { + + binding.backBtn.setOnClickListener(v -> Navigation.findNavController(v).popBackStack()); + + binding.submit.setOnClickListener(v -> + Navigation.findNavController(v).navigate(R.id.action_checkMailFragment_to_changePinFragment)); + + } +} diff --git a/app/src/main/java/com/ssb/simplitend/welcome/fragments/forgotpin/ForgotPinFragment.java b/app/src/main/java/com/ssb/simplitend/welcome/fragments/forgotpin/ForgotPinFragment.java new file mode 100644 index 0000000..f3309b8 --- /dev/null +++ b/app/src/main/java/com/ssb/simplitend/welcome/fragments/forgotpin/ForgotPinFragment.java @@ -0,0 +1,43 @@ +package com.ssb.simplitend.welcome.fragments.forgotpin; + +import android.os.Bundle; +import android.view.LayoutInflater; +import android.view.View; +import android.view.ViewGroup; + +import androidx.annotation.NonNull; +import androidx.annotation.Nullable; +import androidx.fragment.app.Fragment; +import androidx.navigation.Navigation; + +import com.ssb.simplitend.R; +import com.ssb.simplitend.databinding.ForgotPinFragmentBinding; + +public class ForgotPinFragment extends Fragment { + + protected ForgotPinFragmentBinding binding; + + public ForgotPinFragment(){ + // required empty constructor + } + + @Nullable + @Override + public View onCreateView(@NonNull LayoutInflater inflater, @Nullable ViewGroup container, @Nullable Bundle savedInstanceState) { + binding = ForgotPinFragmentBinding.inflate(inflater, container, false); + + clickEvents(); + + return binding.getRoot(); + } + + private void clickEvents() { + + binding.backBtn.setOnClickListener(v -> + Navigation.findNavController(v).popBackStack()); + + binding.submit.setOnClickListener(v -> + Navigation.findNavController(v).navigate(R.id.action_forgotPinFragment_to_checkMailFragment)); + + } +} diff --git a/app/src/main/java/com/ssb/simplitend/welcome/fragments/onboardfragments/OnBoardOne.java b/app/src/main/java/com/ssb/simplitend/welcome/fragments/onboardfragments/OnBoardOne.java new file mode 100644 index 0000000..2e3ccca --- /dev/null +++ b/app/src/main/java/com/ssb/simplitend/welcome/fragments/onboardfragments/OnBoardOne.java @@ -0,0 +1,30 @@ +package com.ssb.simplitend.welcome.fragments.onboardfragments; + +import android.os.Bundle; +import android.view.LayoutInflater; +import android.view.View; +import android.view.ViewGroup; + +import androidx.annotation.NonNull; +import androidx.annotation.Nullable; +import androidx.fragment.app.Fragment; + +import com.ssb.simplitend.databinding.OnboardOneFragmentBinding; + +public class OnBoardOne extends Fragment { + + // view binding + protected OnboardOneFragmentBinding binding; + + public OnBoardOne(){ + // required empty constructor + } + + @Nullable + @Override + public View onCreateView(@NonNull LayoutInflater inflater, @Nullable ViewGroup container, @Nullable Bundle savedInstanceState) { + binding = OnboardOneFragmentBinding.inflate(inflater, container, false); + + return binding.getRoot(); + } +} diff --git a/app/src/main/java/com/ssb/simplitend/welcome/fragments/onboardfragments/OnBoardThree.java b/app/src/main/java/com/ssb/simplitend/welcome/fragments/onboardfragments/OnBoardThree.java new file mode 100644 index 0000000..a03cfb8 --- /dev/null +++ b/app/src/main/java/com/ssb/simplitend/welcome/fragments/onboardfragments/OnBoardThree.java @@ -0,0 +1,31 @@ +package com.ssb.simplitend.welcome.fragments.onboardfragments; + +import android.os.Bundle; +import android.view.LayoutInflater; +import android.view.View; +import android.view.ViewGroup; + +import androidx.annotation.NonNull; +import androidx.annotation.Nullable; +import androidx.fragment.app.Fragment; + +import com.ssb.simplitend.databinding.OnboardOneFragmentBinding; +import com.ssb.simplitend.databinding.OnboardThreeFragmentBinding; + +public class OnBoardThree extends Fragment { + + // view binding + protected OnboardThreeFragmentBinding binding; + + public OnBoardThree(){ + // required empty constructor + } + + @Nullable + @Override + public View onCreateView(@NonNull LayoutInflater inflater, @Nullable ViewGroup container, @Nullable Bundle savedInstanceState) { + binding = OnboardThreeFragmentBinding.inflate(inflater, container, false); + + return binding.getRoot(); + } +} diff --git a/app/src/main/java/com/ssb/simplitend/welcome/fragments/onboardfragments/OnBoardTwo.java b/app/src/main/java/com/ssb/simplitend/welcome/fragments/onboardfragments/OnBoardTwo.java new file mode 100644 index 0000000..0a8a4ae --- /dev/null +++ b/app/src/main/java/com/ssb/simplitend/welcome/fragments/onboardfragments/OnBoardTwo.java @@ -0,0 +1,31 @@ +package com.ssb.simplitend.welcome.fragments.onboardfragments; + +import android.os.Bundle; +import android.view.LayoutInflater; +import android.view.View; +import android.view.ViewGroup; + +import androidx.annotation.NonNull; +import androidx.annotation.Nullable; +import androidx.fragment.app.Fragment; + +import com.ssb.simplitend.databinding.OnboardOneFragmentBinding; +import com.ssb.simplitend.databinding.OnboardTwoFragmentBinding; + +public class OnBoardTwo extends Fragment { + + // view binding + protected OnboardTwoFragmentBinding binding; + + public OnBoardTwo(){ + // required empty constructor + } + + @Nullable + @Override + public View onCreateView(@NonNull LayoutInflater inflater, @Nullable ViewGroup container, @Nullable Bundle savedInstanceState) { + binding = OnboardTwoFragmentBinding.inflate(inflater, container, false); + + return binding.getRoot(); + } +} diff --git a/app/src/main/java/com/ssb/simplitend/welcome/fragments/register/CreatePinFragment.java b/app/src/main/java/com/ssb/simplitend/welcome/fragments/register/CreatePinFragment.java new file mode 100644 index 0000000..e0e15d4 --- /dev/null +++ b/app/src/main/java/com/ssb/simplitend/welcome/fragments/register/CreatePinFragment.java @@ -0,0 +1,44 @@ +package com.ssb.simplitend.welcome.fragments.register; + +import android.os.Bundle; +import android.view.LayoutInflater; +import android.view.View; +import android.view.ViewGroup; + +import androidx.annotation.NonNull; +import androidx.annotation.Nullable; +import androidx.fragment.app.Fragment; +import androidx.navigation.Navigation; + +import com.ssb.simplitend.R; +import com.ssb.simplitend.databinding.CreatePinFragmentBinding; + +public class CreatePinFragment extends Fragment { + + // view binding + protected CreatePinFragmentBinding binding; + + public CreatePinFragment(){ + // required empty const. + } + + @Nullable + @Override + public View onCreateView(@NonNull LayoutInflater inflater, @Nullable ViewGroup container, @Nullable Bundle savedInstanceState) { + binding = CreatePinFragmentBinding.inflate(inflater, container, false); + + clickEvents(); + + return binding.getRoot(); + } + + private void clickEvents() { + + binding.backBtn.setOnClickListener(v -> Navigation.findNavController(v).popBackStack()); + + binding.setPin.setOnClickListener(v -> + Navigation.findNavController(v).navigate(R.id.action_createPinFragment_to_thankYouFragment) + ); + + } +} diff --git a/app/src/main/java/com/ssb/simplitend/welcome/fragments/register/HowToSetUpFragment.java b/app/src/main/java/com/ssb/simplitend/welcome/fragments/register/HowToSetUpFragment.java new file mode 100644 index 0000000..e1d7abf --- /dev/null +++ b/app/src/main/java/com/ssb/simplitend/welcome/fragments/register/HowToSetUpFragment.java @@ -0,0 +1,34 @@ +package com.ssb.simplitend.welcome.fragments.register; + +import android.os.Bundle; +import android.view.LayoutInflater; +import android.view.View; +import android.view.ViewGroup; + +import androidx.annotation.NonNull; +import androidx.annotation.Nullable; +import androidx.fragment.app.Fragment; +import androidx.navigation.Navigation; + +import com.ssb.simplitend.R; +import com.ssb.simplitend.databinding.HowToSetUpFragmentBinding; + +public class HowToSetUpFragment extends Fragment { + + // view binding + protected HowToSetUpFragmentBinding binding; + + public HowToSetUpFragment(){ + // required empty const. + } + + @Nullable + @Override + public View onCreateView(@NonNull LayoutInflater inflater, @Nullable ViewGroup container, @Nullable Bundle savedInstanceState) { + binding = HowToSetUpFragmentBinding.inflate(inflater, container, false); + + binding.nextBtn.setOnClickListener(v -> Navigation.findNavController(v).navigate(R.id.action_howToSetUpFragment_to_registerFragment)); + + return binding.getRoot(); + } +} diff --git a/app/src/main/java/com/ssb/simplitend/welcome/fragments/register/LocationFragment.java b/app/src/main/java/com/ssb/simplitend/welcome/fragments/register/LocationFragment.java new file mode 100644 index 0000000..6dff48c --- /dev/null +++ b/app/src/main/java/com/ssb/simplitend/welcome/fragments/register/LocationFragment.java @@ -0,0 +1,44 @@ +package com.ssb.simplitend.welcome.fragments.register; + +import android.os.Bundle; +import android.view.LayoutInflater; +import android.view.View; +import android.view.ViewGroup; + +import androidx.annotation.NonNull; +import androidx.annotation.Nullable; +import androidx.fragment.app.Fragment; +import androidx.navigation.Navigation; + +import com.ssb.simplitend.R; +import com.ssb.simplitend.databinding.LocationFragmentBinding; + +public class LocationFragment extends Fragment { + + // view binding + protected LocationFragmentBinding binding; + + public LocationFragment(){ + // required empty const. + } + + @Nullable + @Override + public View onCreateView(@NonNull LayoutInflater inflater, @Nullable ViewGroup container, @Nullable Bundle savedInstanceState) { + binding = LocationFragmentBinding.inflate(inflater, container, false); + + clickEvents(); + + return binding.getRoot(); + } + + private void clickEvents() { + + binding.backBtn.setOnClickListener(v -> Navigation.findNavController(v).popBackStack()); + + binding.submit.setOnClickListener(v -> + Navigation.findNavController(v).navigate(R.id.action_locationFragment_to_createPinFragment) + ); + + } +} diff --git a/app/src/main/java/com/ssb/simplitend/welcome/fragments/register/RegisterFragment.java b/app/src/main/java/com/ssb/simplitend/welcome/fragments/register/RegisterFragment.java new file mode 100644 index 0000000..018aad2 --- /dev/null +++ b/app/src/main/java/com/ssb/simplitend/welcome/fragments/register/RegisterFragment.java @@ -0,0 +1,42 @@ +package com.ssb.simplitend.welcome.fragments.register; + +import android.os.Bundle; +import android.view.LayoutInflater; +import android.view.View; +import android.view.ViewGroup; + +import androidx.annotation.NonNull; +import androidx.annotation.Nullable; +import androidx.fragment.app.Fragment; +import androidx.navigation.Navigation; + +import com.ssb.simplitend.R; +import com.ssb.simplitend.databinding.RegisterFragmentBinding; + +public class RegisterFragment extends Fragment { + + protected RegisterFragmentBinding binding; + + public RegisterFragment(){ + // required empty const. + } + + @Nullable + @Override + public View onCreateView(@NonNull LayoutInflater inflater, @Nullable ViewGroup container, @Nullable Bundle savedInstanceState) { + binding = RegisterFragmentBinding.inflate(inflater, container, false); + + clickEvents(); + + return binding.getRoot(); + } + + private void clickEvents() { + + binding.backBtn.setOnClickListener(v -> Navigation.findNavController(v).popBackStack()); + + binding.nextBtn.setOnClickListener(v -> + Navigation.findNavController(v).navigate(R.id.action_registerFragment_to_locationFragment)); + + } +} diff --git a/app/src/main/java/com/ssb/simplitend/welcome/fragments/register/ThankYouFragment.java b/app/src/main/java/com/ssb/simplitend/welcome/fragments/register/ThankYouFragment.java new file mode 100644 index 0000000..220ae22 --- /dev/null +++ b/app/src/main/java/com/ssb/simplitend/welcome/fragments/register/ThankYouFragment.java @@ -0,0 +1,54 @@ +package com.ssb.simplitend.welcome.fragments.register; + +import android.os.Bundle; +import android.view.LayoutInflater; +import android.view.View; +import android.view.ViewGroup; + +import androidx.annotation.NonNull; +import androidx.annotation.Nullable; +import androidx.fragment.app.Fragment; +import androidx.navigation.Navigation; + +import com.bumptech.glide.Glide; +import com.bumptech.glide.load.engine.DiskCacheStrategy; +import com.squareup.picasso.Picasso; +import com.ssb.simplitend.R; +import com.ssb.simplitend.databinding.LocationFragmentBinding; +import com.ssb.simplitend.databinding.ThankYouFragmentBinding; + +public class ThankYouFragment extends Fragment { + + // view binding + protected ThankYouFragmentBinding binding; + + public ThankYouFragment(){ + // required empty const. + } + + @Nullable + @Override + public View onCreateView(@NonNull LayoutInflater inflater, @Nullable ViewGroup container, @Nullable Bundle savedInstanceState) { + binding = ThankYouFragmentBinding.inflate(inflater, container, false); + + initializeViews(savedInstanceState); + + clickEvents(); + + return binding.getRoot(); + } + + private void initializeViews(Bundle savedInstanceState) { + } + + private void clickEvents() { + + binding.backBtn.setOnClickListener(v -> Navigation.findNavController(v).popBackStack()); + + binding.proceed.setOnClickListener(v -> + Navigation.findNavController(v).navigate(R.id.action_thankYouFragment_to_contactListFragment) + ); + + } +} + diff --git a/app/src/main/res/drawable-hdpi/caregiver_img.png b/app/src/main/res/drawable-hdpi/caregiver_img.png new file mode 100644 index 0000000..54394e3 Binary files /dev/null and b/app/src/main/res/drawable-hdpi/caregiver_img.png differ diff --git a/app/src/main/res/drawable-hdpi/forget_pin_email_img.png b/app/src/main/res/drawable-hdpi/forget_pin_email_img.png new file mode 100644 index 0000000..21411c1 Binary files /dev/null and b/app/src/main/res/drawable-hdpi/forget_pin_email_img.png differ diff --git a/app/src/main/res/drawable-hdpi/senior_img.png b/app/src/main/res/drawable-hdpi/senior_img.png new file mode 100644 index 0000000..ffc5d39 Binary files /dev/null and b/app/src/main/res/drawable-hdpi/senior_img.png differ diff --git a/app/src/main/res/drawable-hdpi/static_1.png b/app/src/main/res/drawable-hdpi/static_1.png new file mode 100644 index 0000000..239d75d Binary files /dev/null and b/app/src/main/res/drawable-hdpi/static_1.png differ diff --git a/app/src/main/res/drawable-hdpi/static_2.png b/app/src/main/res/drawable-hdpi/static_2.png new file mode 100644 index 0000000..f0d6e6a Binary files /dev/null and b/app/src/main/res/drawable-hdpi/static_2.png differ diff --git a/app/src/main/res/drawable-hdpi/static_3.png b/app/src/main/res/drawable-hdpi/static_3.png new file mode 100644 index 0000000..b0aa8b8 Binary files /dev/null and b/app/src/main/res/drawable-hdpi/static_3.png differ diff --git a/app/src/main/res/drawable-hdpi/welcome_img.png b/app/src/main/res/drawable-hdpi/welcome_img.png new file mode 100644 index 0000000..ab57705 Binary files /dev/null and b/app/src/main/res/drawable-hdpi/welcome_img.png differ diff --git a/app/src/main/res/drawable-ldpi/caregiver_img.png b/app/src/main/res/drawable-ldpi/caregiver_img.png new file mode 100644 index 0000000..49e3281 Binary files /dev/null and b/app/src/main/res/drawable-ldpi/caregiver_img.png differ diff --git a/app/src/main/res/drawable-ldpi/forget_pin_email_img.png b/app/src/main/res/drawable-ldpi/forget_pin_email_img.png new file mode 100644 index 0000000..0dbefd9 Binary files /dev/null and b/app/src/main/res/drawable-ldpi/forget_pin_email_img.png differ diff --git a/app/src/main/res/drawable-ldpi/senior_img.png b/app/src/main/res/drawable-ldpi/senior_img.png new file mode 100644 index 0000000..8df9640 Binary files /dev/null and b/app/src/main/res/drawable-ldpi/senior_img.png differ diff --git a/app/src/main/res/drawable-ldpi/static_1.png b/app/src/main/res/drawable-ldpi/static_1.png new file mode 100644 index 0000000..e1b10c3 Binary files /dev/null and b/app/src/main/res/drawable-ldpi/static_1.png differ diff --git a/app/src/main/res/drawable-ldpi/static_2.png b/app/src/main/res/drawable-ldpi/static_2.png new file mode 100644 index 0000000..86b8f98 Binary files /dev/null and b/app/src/main/res/drawable-ldpi/static_2.png differ diff --git a/app/src/main/res/drawable-ldpi/static_3.png b/app/src/main/res/drawable-ldpi/static_3.png new file mode 100644 index 0000000..b865f26 Binary files /dev/null and b/app/src/main/res/drawable-ldpi/static_3.png differ diff --git a/app/src/main/res/drawable-ldpi/welcome_img.png b/app/src/main/res/drawable-ldpi/welcome_img.png new file mode 100644 index 0000000..b820427 Binary files /dev/null and b/app/src/main/res/drawable-ldpi/welcome_img.png differ diff --git a/app/src/main/res/drawable-mdpi/caregiver_img.png b/app/src/main/res/drawable-mdpi/caregiver_img.png new file mode 100644 index 0000000..dc8c102 Binary files /dev/null and b/app/src/main/res/drawable-mdpi/caregiver_img.png differ diff --git a/app/src/main/res/drawable-mdpi/forget_pin_email_img.png b/app/src/main/res/drawable-mdpi/forget_pin_email_img.png new file mode 100644 index 0000000..f4549a7 Binary files /dev/null and b/app/src/main/res/drawable-mdpi/forget_pin_email_img.png differ diff --git a/app/src/main/res/drawable-mdpi/ic_dob.xml b/app/src/main/res/drawable-mdpi/ic_dob.xml new file mode 100644 index 0000000..b2497c4 --- /dev/null +++ b/app/src/main/res/drawable-mdpi/ic_dob.xml @@ -0,0 +1,10 @@ + + + + + + + + \ No newline at end of file diff --git a/app/src/main/res/drawable-mdpi/ic_email.xml b/app/src/main/res/drawable-mdpi/ic_email.xml new file mode 100644 index 0000000..7e5a3bf --- /dev/null +++ b/app/src/main/res/drawable-mdpi/ic_email.xml @@ -0,0 +1,10 @@ + + + + + + + + \ No newline at end of file diff --git a/app/src/main/res/drawable-mdpi/ic_phone.xml b/app/src/main/res/drawable-mdpi/ic_phone.xml new file mode 100644 index 0000000..e7250b4 --- /dev/null +++ b/app/src/main/res/drawable-mdpi/ic_phone.xml @@ -0,0 +1,10 @@ + + + + + + + + \ No newline at end of file diff --git a/app/src/main/res/drawable-mdpi/senior_img.png b/app/src/main/res/drawable-mdpi/senior_img.png new file mode 100644 index 0000000..219002c Binary files /dev/null and b/app/src/main/res/drawable-mdpi/senior_img.png differ diff --git a/app/src/main/res/drawable-mdpi/static_1.png b/app/src/main/res/drawable-mdpi/static_1.png new file mode 100644 index 0000000..88c29fc Binary files /dev/null and b/app/src/main/res/drawable-mdpi/static_1.png differ diff --git a/app/src/main/res/drawable-mdpi/static_2.png b/app/src/main/res/drawable-mdpi/static_2.png new file mode 100644 index 0000000..a8d5df4 Binary files /dev/null and b/app/src/main/res/drawable-mdpi/static_2.png differ diff --git a/app/src/main/res/drawable-mdpi/static_3.png b/app/src/main/res/drawable-mdpi/static_3.png new file mode 100644 index 0000000..9c36d9f Binary files /dev/null and b/app/src/main/res/drawable-mdpi/static_3.png differ diff --git a/app/src/main/res/drawable-mdpi/welcome_img.png b/app/src/main/res/drawable-mdpi/welcome_img.png new file mode 100644 index 0000000..a309eea Binary files /dev/null and b/app/src/main/res/drawable-mdpi/welcome_img.png differ diff --git a/app/src/main/res/drawable-v24/ic_launcher_foreground.xml b/app/src/main/res/drawable-v24/ic_launcher_foreground.xml new file mode 100644 index 0000000..2b068d1 --- /dev/null +++ b/app/src/main/res/drawable-v24/ic_launcher_foreground.xml @@ -0,0 +1,30 @@ + + + + + + + + + + + \ No newline at end of file diff --git a/app/src/main/res/drawable-xhdpi/caregiver_img.png b/app/src/main/res/drawable-xhdpi/caregiver_img.png new file mode 100644 index 0000000..68a4849 Binary files /dev/null and b/app/src/main/res/drawable-xhdpi/caregiver_img.png differ diff --git a/app/src/main/res/drawable-xhdpi/forget_pin_email_img.png b/app/src/main/res/drawable-xhdpi/forget_pin_email_img.png new file mode 100644 index 0000000..721cf99 Binary files /dev/null and b/app/src/main/res/drawable-xhdpi/forget_pin_email_img.png differ diff --git a/app/src/main/res/drawable-xhdpi/senior_img.png b/app/src/main/res/drawable-xhdpi/senior_img.png new file mode 100644 index 0000000..6005d41 Binary files /dev/null and b/app/src/main/res/drawable-xhdpi/senior_img.png differ diff --git a/app/src/main/res/drawable-xhdpi/static_1.png b/app/src/main/res/drawable-xhdpi/static_1.png new file mode 100644 index 0000000..794936e Binary files /dev/null and b/app/src/main/res/drawable-xhdpi/static_1.png differ diff --git a/app/src/main/res/drawable-xhdpi/static_2.png b/app/src/main/res/drawable-xhdpi/static_2.png new file mode 100644 index 0000000..7bfac7a Binary files /dev/null and b/app/src/main/res/drawable-xhdpi/static_2.png differ diff --git a/app/src/main/res/drawable-xhdpi/static_3.png b/app/src/main/res/drawable-xhdpi/static_3.png new file mode 100644 index 0000000..16f8c2b Binary files /dev/null and b/app/src/main/res/drawable-xhdpi/static_3.png differ diff --git a/app/src/main/res/drawable-xhdpi/unselected_dot_accent.xml b/app/src/main/res/drawable-xhdpi/unselected_dot_accent.xml new file mode 100644 index 0000000..3868823 --- /dev/null +++ b/app/src/main/res/drawable-xhdpi/unselected_dot_accent.xml @@ -0,0 +1,10 @@ + + + + + + \ No newline at end of file diff --git a/app/src/main/res/drawable-xhdpi/welcome_img.png b/app/src/main/res/drawable-xhdpi/welcome_img.png new file mode 100644 index 0000000..0240d93 Binary files /dev/null and b/app/src/main/res/drawable-xhdpi/welcome_img.png differ diff --git a/app/src/main/res/drawable-xxhdpi/caregiver_img.png b/app/src/main/res/drawable-xxhdpi/caregiver_img.png new file mode 100644 index 0000000..8b65ad3 Binary files /dev/null and b/app/src/main/res/drawable-xxhdpi/caregiver_img.png differ diff --git a/app/src/main/res/drawable-xxhdpi/forget_pin_email_img.png b/app/src/main/res/drawable-xxhdpi/forget_pin_email_img.png new file mode 100644 index 0000000..d0ff4ce Binary files /dev/null and b/app/src/main/res/drawable-xxhdpi/forget_pin_email_img.png differ diff --git a/app/src/main/res/drawable-xxhdpi/senior_img.png b/app/src/main/res/drawable-xxhdpi/senior_img.png new file mode 100644 index 0000000..be54a79 Binary files /dev/null and b/app/src/main/res/drawable-xxhdpi/senior_img.png differ diff --git a/app/src/main/res/drawable-xxhdpi/static_1.png b/app/src/main/res/drawable-xxhdpi/static_1.png new file mode 100644 index 0000000..2812de3 Binary files /dev/null and b/app/src/main/res/drawable-xxhdpi/static_1.png differ diff --git a/app/src/main/res/drawable-xxhdpi/static_2.png b/app/src/main/res/drawable-xxhdpi/static_2.png new file mode 100644 index 0000000..bf978cd Binary files /dev/null and b/app/src/main/res/drawable-xxhdpi/static_2.png differ diff --git a/app/src/main/res/drawable-xxhdpi/static_3.png b/app/src/main/res/drawable-xxhdpi/static_3.png new file mode 100644 index 0000000..c18063e Binary files /dev/null and b/app/src/main/res/drawable-xxhdpi/static_3.png differ diff --git a/app/src/main/res/drawable-xxhdpi/welcome_img.png b/app/src/main/res/drawable-xxhdpi/welcome_img.png new file mode 100644 index 0000000..d164760 Binary files /dev/null and b/app/src/main/res/drawable-xxhdpi/welcome_img.png differ diff --git a/app/src/main/res/drawable-xxxhdpi/caregiver_img.png b/app/src/main/res/drawable-xxxhdpi/caregiver_img.png new file mode 100644 index 0000000..f82cbd1 Binary files /dev/null and b/app/src/main/res/drawable-xxxhdpi/caregiver_img.png differ diff --git a/app/src/main/res/drawable-xxxhdpi/forget_pin_email_img.png b/app/src/main/res/drawable-xxxhdpi/forget_pin_email_img.png new file mode 100644 index 0000000..84d2896 Binary files /dev/null and b/app/src/main/res/drawable-xxxhdpi/forget_pin_email_img.png differ diff --git a/app/src/main/res/drawable-xxxhdpi/senior_img.png b/app/src/main/res/drawable-xxxhdpi/senior_img.png new file mode 100644 index 0000000..866dca8 Binary files /dev/null and b/app/src/main/res/drawable-xxxhdpi/senior_img.png differ diff --git a/app/src/main/res/drawable-xxxhdpi/static_1.png b/app/src/main/res/drawable-xxxhdpi/static_1.png new file mode 100644 index 0000000..6b22fbd Binary files /dev/null and b/app/src/main/res/drawable-xxxhdpi/static_1.png differ diff --git a/app/src/main/res/drawable-xxxhdpi/static_2.png b/app/src/main/res/drawable-xxxhdpi/static_2.png new file mode 100644 index 0000000..a47b70e Binary files /dev/null and b/app/src/main/res/drawable-xxxhdpi/static_2.png differ diff --git a/app/src/main/res/drawable-xxxhdpi/static_3.png b/app/src/main/res/drawable-xxxhdpi/static_3.png new file mode 100644 index 0000000..536969a Binary files /dev/null and b/app/src/main/res/drawable-xxxhdpi/static_3.png differ diff --git a/app/src/main/res/drawable-xxxhdpi/welcome_img.png b/app/src/main/res/drawable-xxxhdpi/welcome_img.png new file mode 100644 index 0000000..ff22c91 Binary files /dev/null and b/app/src/main/res/drawable-xxxhdpi/welcome_img.png differ diff --git a/app/src/main/res/drawable/arrow_back.xml b/app/src/main/res/drawable/arrow_back.xml new file mode 100644 index 0000000..6dd8758 --- /dev/null +++ b/app/src/main/res/drawable/arrow_back.xml @@ -0,0 +1,13 @@ + + + diff --git a/app/src/main/res/drawable/checked_bpx.xml b/app/src/main/res/drawable/checked_bpx.xml new file mode 100644 index 0000000..9cf74d8 --- /dev/null +++ b/app/src/main/res/drawable/checked_bpx.xml @@ -0,0 +1,23 @@ + + + + + diff --git a/app/src/main/res/drawable/edit_text_bg.xml b/app/src/main/res/drawable/edit_text_bg.xml new file mode 100644 index 0000000..0126984 --- /dev/null +++ b/app/src/main/res/drawable/edit_text_bg.xml @@ -0,0 +1,14 @@ + + + + + + + + + + \ No newline at end of file diff --git a/app/src/main/res/drawable/edit_text_bg_2.xml b/app/src/main/res/drawable/edit_text_bg_2.xml new file mode 100644 index 0000000..3f055a4 --- /dev/null +++ b/app/src/main/res/drawable/edit_text_bg_2.xml @@ -0,0 +1,12 @@ + + + + + + + + + + \ No newline at end of file diff --git a/app/src/main/res/drawable/green_check.xml b/app/src/main/res/drawable/green_check.xml new file mode 100644 index 0000000..fcdeffd --- /dev/null +++ b/app/src/main/res/drawable/green_check.xml @@ -0,0 +1,16 @@ + + + + diff --git a/app/src/main/res/drawable/ic_accent_bg.xml b/app/src/main/res/drawable/ic_accent_bg.xml new file mode 100644 index 0000000..1b9f166 --- /dev/null +++ b/app/src/main/res/drawable/ic_accent_bg.xml @@ -0,0 +1,9 @@ + + + diff --git a/app/src/main/res/drawable/ic_add_img_outline.xml b/app/src/main/res/drawable/ic_add_img_outline.xml new file mode 100644 index 0000000..26093d9 --- /dev/null +++ b/app/src/main/res/drawable/ic_add_img_outline.xml @@ -0,0 +1,9 @@ + + + diff --git a/app/src/main/res/drawable/ic_apps.xml b/app/src/main/res/drawable/ic_apps.xml new file mode 100644 index 0000000..ffb1eba --- /dev/null +++ b/app/src/main/res/drawable/ic_apps.xml @@ -0,0 +1,5 @@ + + + diff --git a/app/src/main/res/drawable/ic_calender.xml b/app/src/main/res/drawable/ic_calender.xml new file mode 100644 index 0000000..b89360f --- /dev/null +++ b/app/src/main/res/drawable/ic_calender.xml @@ -0,0 +1,5 @@ + + + diff --git a/app/src/main/res/drawable/ic_contact_outline.xml b/app/src/main/res/drawable/ic_contact_outline.xml new file mode 100644 index 0000000..10d348c --- /dev/null +++ b/app/src/main/res/drawable/ic_contact_outline.xml @@ -0,0 +1,5 @@ + + + diff --git a/app/src/main/res/drawable/ic_delete_outline.xml b/app/src/main/res/drawable/ic_delete_outline.xml new file mode 100644 index 0000000..9dbf0e4 --- /dev/null +++ b/app/src/main/res/drawable/ic_delete_outline.xml @@ -0,0 +1,12 @@ + + + + diff --git a/app/src/main/res/drawable/ic_dob_outline.xml b/app/src/main/res/drawable/ic_dob_outline.xml new file mode 100644 index 0000000..dea5256 --- /dev/null +++ b/app/src/main/res/drawable/ic_dob_outline.xml @@ -0,0 +1,34 @@ + + + + + + diff --git a/app/src/main/res/drawable/ic_done.xml b/app/src/main/res/drawable/ic_done.xml new file mode 100644 index 0000000..25e5251 --- /dev/null +++ b/app/src/main/res/drawable/ic_done.xml @@ -0,0 +1,5 @@ + + + diff --git a/app/src/main/res/drawable/ic_edit_outline.xml b/app/src/main/res/drawable/ic_edit_outline.xml new file mode 100644 index 0000000..93ec78c --- /dev/null +++ b/app/src/main/res/drawable/ic_edit_outline.xml @@ -0,0 +1,27 @@ + + + + + diff --git a/app/src/main/res/drawable/ic_email_outline.xml b/app/src/main/res/drawable/ic_email_outline.xml new file mode 100644 index 0000000..0f4d5d9 --- /dev/null +++ b/app/src/main/res/drawable/ic_email_outline.xml @@ -0,0 +1,19 @@ + + + + diff --git a/app/src/main/res/drawable/ic_forward_error.xml b/app/src/main/res/drawable/ic_forward_error.xml new file mode 100644 index 0000000..61a6316 --- /dev/null +++ b/app/src/main/res/drawable/ic_forward_error.xml @@ -0,0 +1,9 @@ + + + diff --git a/app/src/main/res/drawable/ic_home.xml b/app/src/main/res/drawable/ic_home.xml new file mode 100644 index 0000000..341f66a --- /dev/null +++ b/app/src/main/res/drawable/ic_home.xml @@ -0,0 +1,10 @@ + + + + + + + + \ No newline at end of file diff --git a/app/src/main/res/drawable/ic_home_outline.xml b/app/src/main/res/drawable/ic_home_outline.xml new file mode 100644 index 0000000..464f16d --- /dev/null +++ b/app/src/main/res/drawable/ic_home_outline.xml @@ -0,0 +1,20 @@ + + + + diff --git a/app/src/main/res/drawable/ic_launcher_background.xml b/app/src/main/res/drawable/ic_launcher_background.xml new file mode 100644 index 0000000..07d5da9 --- /dev/null +++ b/app/src/main/res/drawable/ic_launcher_background.xml @@ -0,0 +1,170 @@ + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + diff --git a/app/src/main/res/drawable/ic_line_vert.xml b/app/src/main/res/drawable/ic_line_vert.xml new file mode 100644 index 0000000..2c9a5c6 --- /dev/null +++ b/app/src/main/res/drawable/ic_line_vert.xml @@ -0,0 +1,12 @@ + + + diff --git a/app/src/main/res/drawable/ic_lock.xml b/app/src/main/res/drawable/ic_lock.xml new file mode 100644 index 0000000..2907967 --- /dev/null +++ b/app/src/main/res/drawable/ic_lock.xml @@ -0,0 +1,10 @@ + + + + + + + + \ No newline at end of file diff --git a/app/src/main/res/drawable/ic_lock_outline.xml b/app/src/main/res/drawable/ic_lock_outline.xml new file mode 100644 index 0000000..407ed06 --- /dev/null +++ b/app/src/main/res/drawable/ic_lock_outline.xml @@ -0,0 +1,20 @@ + + + + diff --git a/app/src/main/res/drawable/ic_medical.xml b/app/src/main/res/drawable/ic_medical.xml new file mode 100644 index 0000000..9ea0deb --- /dev/null +++ b/app/src/main/res/drawable/ic_medical.xml @@ -0,0 +1,5 @@ + + + diff --git a/app/src/main/res/drawable/ic_msg_img.xml b/app/src/main/res/drawable/ic_msg_img.xml new file mode 100644 index 0000000..33e54e2 --- /dev/null +++ b/app/src/main/res/drawable/ic_msg_img.xml @@ -0,0 +1,36 @@ + + + + + + + diff --git a/app/src/main/res/drawable/ic_phone_img.xml b/app/src/main/res/drawable/ic_phone_img.xml new file mode 100644 index 0000000..edd0f37 --- /dev/null +++ b/app/src/main/res/drawable/ic_phone_img.xml @@ -0,0 +1,19 @@ + + + + + diff --git a/app/src/main/res/drawable/ic_phone_outline.xml b/app/src/main/res/drawable/ic_phone_outline.xml new file mode 100644 index 0000000..19ece1d --- /dev/null +++ b/app/src/main/res/drawable/ic_phone_outline.xml @@ -0,0 +1,9 @@ + + + diff --git a/app/src/main/res/drawable/ic_relation.xml b/app/src/main/res/drawable/ic_relation.xml new file mode 100644 index 0000000..70c4fa5 --- /dev/null +++ b/app/src/main/res/drawable/ic_relation.xml @@ -0,0 +1,10 @@ + + + + + + + + \ No newline at end of file diff --git a/app/src/main/res/drawable/ic_relation_outline.xml b/app/src/main/res/drawable/ic_relation_outline.xml new file mode 100644 index 0000000..89f88f0 --- /dev/null +++ b/app/src/main/res/drawable/ic_relation_outline.xml @@ -0,0 +1,76 @@ + + + + + + + + + + + + diff --git a/app/src/main/res/drawable/ic_right_kb.xml b/app/src/main/res/drawable/ic_right_kb.xml new file mode 100644 index 0000000..5d47b4d --- /dev/null +++ b/app/src/main/res/drawable/ic_right_kb.xml @@ -0,0 +1,5 @@ + + + diff --git a/app/src/main/res/drawable/ic_search_outline.xml b/app/src/main/res/drawable/ic_search_outline.xml new file mode 100644 index 0000000..b5fc10b --- /dev/null +++ b/app/src/main/res/drawable/ic_search_outline.xml @@ -0,0 +1,20 @@ + + + + diff --git a/app/src/main/res/drawable/ic_setup_bg.xml b/app/src/main/res/drawable/ic_setup_bg.xml new file mode 100644 index 0000000..c179534 --- /dev/null +++ b/app/src/main/res/drawable/ic_setup_bg.xml @@ -0,0 +1,11 @@ + + + + + + + + \ No newline at end of file diff --git a/app/src/main/res/drawable/ic_show_password.xml b/app/src/main/res/drawable/ic_show_password.xml new file mode 100644 index 0000000..06a733a --- /dev/null +++ b/app/src/main/res/drawable/ic_show_password.xml @@ -0,0 +1,20 @@ + + + + diff --git a/app/src/main/res/drawable/ic_timer.xml b/app/src/main/res/drawable/ic_timer.xml new file mode 100644 index 0000000..7732df4 --- /dev/null +++ b/app/src/main/res/drawable/ic_timer.xml @@ -0,0 +1,6 @@ + + + + diff --git a/app/src/main/res/drawable/ic_user.xml b/app/src/main/res/drawable/ic_user.xml new file mode 100644 index 0000000..76795cb --- /dev/null +++ b/app/src/main/res/drawable/ic_user.xml @@ -0,0 +1,10 @@ + + + + + + + + \ No newline at end of file diff --git a/app/src/main/res/drawable/ic_user_outline.xml b/app/src/main/res/drawable/ic_user_outline.xml new file mode 100644 index 0000000..a380fb6 --- /dev/null +++ b/app/src/main/res/drawable/ic_user_outline.xml @@ -0,0 +1,27 @@ + + + + + diff --git a/app/src/main/res/drawable/ic_user_outline_bg.xml b/app/src/main/res/drawable/ic_user_outline_bg.xml new file mode 100644 index 0000000..8c127ad --- /dev/null +++ b/app/src/main/res/drawable/ic_user_outline_bg.xml @@ -0,0 +1,9 @@ + + + diff --git a/app/src/main/res/drawable/ic_white_bg.xml b/app/src/main/res/drawable/ic_white_bg.xml new file mode 100644 index 0000000..d29c1b0 --- /dev/null +++ b/app/src/main/res/drawable/ic_white_bg.xml @@ -0,0 +1,16 @@ + + + + diff --git a/app/src/main/res/drawable/icon_bg.xml b/app/src/main/res/drawable/icon_bg.xml new file mode 100644 index 0000000..2a481c0 --- /dev/null +++ b/app/src/main/res/drawable/icon_bg.xml @@ -0,0 +1,9 @@ + + + diff --git a/app/src/main/res/drawable/img_bg_1.xml b/app/src/main/res/drawable/img_bg_1.xml new file mode 100644 index 0000000..a0e70f6 --- /dev/null +++ b/app/src/main/res/drawable/img_bg_1.xml @@ -0,0 +1,16 @@ + + + + diff --git a/app/src/main/res/drawable/main_icon.xml b/app/src/main/res/drawable/main_icon.xml new file mode 100644 index 0000000..e69022d --- /dev/null +++ b/app/src/main/res/drawable/main_icon.xml @@ -0,0 +1,14 @@ + + + + + + + + \ No newline at end of file diff --git a/app/src/main/res/drawable/onboard_one.xml b/app/src/main/res/drawable/onboard_one.xml new file mode 100644 index 0000000..1d8b961 --- /dev/null +++ b/app/src/main/res/drawable/onboard_one.xml @@ -0,0 +1,596 @@ + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + diff --git a/app/src/main/res/drawable/onboard_three.xml b/app/src/main/res/drawable/onboard_three.xml new file mode 100644 index 0000000..da17963 --- /dev/null +++ b/app/src/main/res/drawable/onboard_three.xml @@ -0,0 +1,956 @@ + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + diff --git a/app/src/main/res/drawable/onboard_two.xml b/app/src/main/res/drawable/onboard_two.xml new file mode 100644 index 0000000..46766f3 --- /dev/null +++ b/app/src/main/res/drawable/onboard_two.xml @@ -0,0 +1,1027 @@ + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + diff --git a/app/src/main/res/drawable/otp_box_bg.xml b/app/src/main/res/drawable/otp_box_bg.xml new file mode 100644 index 0000000..79a82e9 --- /dev/null +++ b/app/src/main/res/drawable/otp_box_bg.xml @@ -0,0 +1,26 @@ + + + + + + diff --git a/app/src/main/res/drawable/primary_bg.xml b/app/src/main/res/drawable/primary_bg.xml new file mode 100644 index 0000000..01df705 --- /dev/null +++ b/app/src/main/res/drawable/primary_bg.xml @@ -0,0 +1,9 @@ + + + diff --git a/app/src/main/res/drawable/remember_me_selector.xml b/app/src/main/res/drawable/remember_me_selector.xml new file mode 100644 index 0000000..a38fe0c --- /dev/null +++ b/app/src/main/res/drawable/remember_me_selector.xml @@ -0,0 +1,10 @@ + + + + + + + + \ No newline at end of file diff --git a/app/src/main/res/drawable/selected_dot_primary.xml b/app/src/main/res/drawable/selected_dot_primary.xml new file mode 100644 index 0000000..4926d18 --- /dev/null +++ b/app/src/main/res/drawable/selected_dot_primary.xml @@ -0,0 +1,10 @@ + + + + + + \ No newline at end of file diff --git a/app/src/main/res/drawable/switch_thumb_1.xml b/app/src/main/res/drawable/switch_thumb_1.xml new file mode 100644 index 0000000..52ef0fd --- /dev/null +++ b/app/src/main/res/drawable/switch_thumb_1.xml @@ -0,0 +1,12 @@ + + + + + + + + \ No newline at end of file diff --git a/app/src/main/res/drawable/switch_track_1.xml b/app/src/main/res/drawable/switch_track_1.xml new file mode 100644 index 0000000..b552f3c --- /dev/null +++ b/app/src/main/res/drawable/switch_track_1.xml @@ -0,0 +1,20 @@ + + + + + + + + + + + + + + + + + + \ No newline at end of file diff --git a/app/src/main/res/drawable/top_round_corner.xml b/app/src/main/res/drawable/top_round_corner.xml new file mode 100644 index 0000000..c479e38 --- /dev/null +++ b/app/src/main/res/drawable/top_round_corner.xml @@ -0,0 +1,12 @@ + + + + + + + + \ No newline at end of file diff --git a/app/src/main/res/drawable/unchecked_box.xml b/app/src/main/res/drawable/unchecked_box.xml new file mode 100644 index 0000000..562176b --- /dev/null +++ b/app/src/main/res/drawable/unchecked_box.xml @@ -0,0 +1,16 @@ + + + + diff --git a/app/src/main/res/drawable/welcome_bg_2.xml b/app/src/main/res/drawable/welcome_bg_2.xml new file mode 100644 index 0000000..e413721 --- /dev/null +++ b/app/src/main/res/drawable/welcome_bg_2.xml @@ -0,0 +1,11 @@ + + + diff --git a/app/src/main/res/drawable/welcome_illust.xml b/app/src/main/res/drawable/welcome_illust.xml new file mode 100644 index 0000000..5c399a6 --- /dev/null +++ b/app/src/main/res/drawable/welcome_illust.xml @@ -0,0 +1,889 @@ + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + diff --git a/app/src/main/res/drawable/welcome_next.xml b/app/src/main/res/drawable/welcome_next.xml new file mode 100644 index 0000000..290ca6f --- /dev/null +++ b/app/src/main/res/drawable/welcome_next.xml @@ -0,0 +1,16 @@ + + + + diff --git a/app/src/main/res/drawable/welocme_txt_bg.xml b/app/src/main/res/drawable/welocme_txt_bg.xml new file mode 100644 index 0000000..1418958 --- /dev/null +++ b/app/src/main/res/drawable/welocme_txt_bg.xml @@ -0,0 +1,11 @@ + + + diff --git a/app/src/main/res/drawable/white_icon.xml b/app/src/main/res/drawable/white_icon.xml new file mode 100644 index 0000000..afed9d1 --- /dev/null +++ b/app/src/main/res/drawable/white_icon.xml @@ -0,0 +1,12 @@ + + + + diff --git a/app/src/main/res/font/nunito_bold.ttf b/app/src/main/res/font/nunito_bold.ttf new file mode 100644 index 0000000..14be6b7 Binary files /dev/null and b/app/src/main/res/font/nunito_bold.ttf differ diff --git a/app/src/main/res/font/nunito_medium.ttf b/app/src/main/res/font/nunito_medium.ttf new file mode 100644 index 0000000..f9881a0 Binary files /dev/null and b/app/src/main/res/font/nunito_medium.ttf differ diff --git a/app/src/main/res/font/nunito_regular.ttf b/app/src/main/res/font/nunito_regular.ttf new file mode 100644 index 0000000..dfd0fcb Binary files /dev/null and b/app/src/main/res/font/nunito_regular.ttf differ diff --git a/app/src/main/res/font/nunito_semibold.ttf b/app/src/main/res/font/nunito_semibold.ttf new file mode 100644 index 0000000..cec631f Binary files /dev/null and b/app/src/main/res/font/nunito_semibold.ttf differ diff --git a/app/src/main/res/layout/activity_welcome.xml b/app/src/main/res/layout/activity_welcome.xml new file mode 100644 index 0000000..8a4bfea --- /dev/null +++ b/app/src/main/res/layout/activity_welcome.xml @@ -0,0 +1,17 @@ + + + + + + \ No newline at end of file diff --git a/app/src/main/res/layout/add_contact_fragment.xml b/app/src/main/res/layout/add_contact_fragment.xml new file mode 100644 index 0000000..281e95d --- /dev/null +++ b/app/src/main/res/layout/add_contact_fragment.xml @@ -0,0 +1,219 @@ + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + \ No newline at end of file diff --git a/app/src/main/res/layout/change_pin_fragment.xml b/app/src/main/res/layout/change_pin_fragment.xml new file mode 100644 index 0000000..3a745ee --- /dev/null +++ b/app/src/main/res/layout/change_pin_fragment.xml @@ -0,0 +1,130 @@ + + + + + + + + + + + + + + + + + + + + + + + + \ No newline at end of file diff --git a/app/src/main/res/layout/check_mail_fragment.xml b/app/src/main/res/layout/check_mail_fragment.xml new file mode 100644 index 0000000..064b1be --- /dev/null +++ b/app/src/main/res/layout/check_mail_fragment.xml @@ -0,0 +1,225 @@ + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + \ No newline at end of file diff --git a/app/src/main/res/layout/choose_role_fragment.xml b/app/src/main/res/layout/choose_role_fragment.xml new file mode 100644 index 0000000..5f545a2 --- /dev/null +++ b/app/src/main/res/layout/choose_role_fragment.xml @@ -0,0 +1,177 @@ + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + \ No newline at end of file diff --git a/app/src/main/res/layout/contact_info_fragment.xml b/app/src/main/res/layout/contact_info_fragment.xml new file mode 100644 index 0000000..1e4d6fc --- /dev/null +++ b/app/src/main/res/layout/contact_info_fragment.xml @@ -0,0 +1,222 @@ + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + \ No newline at end of file diff --git a/app/src/main/res/layout/contact_list_fragment.xml b/app/src/main/res/layout/contact_list_fragment.xml new file mode 100644 index 0000000..6c886fb --- /dev/null +++ b/app/src/main/res/layout/contact_list_fragment.xml @@ -0,0 +1,88 @@ + + + + + + + + + + + + + + + + + + + + \ No newline at end of file diff --git a/app/src/main/res/layout/contact_view_holder.xml b/app/src/main/res/layout/contact_view_holder.xml new file mode 100644 index 0000000..4ba3fda --- /dev/null +++ b/app/src/main/res/layout/contact_view_holder.xml @@ -0,0 +1,55 @@ + + + + + + + + + + + + + + + + diff --git a/app/src/main/res/layout/create_edit_contact_fragment.xml b/app/src/main/res/layout/create_edit_contact_fragment.xml new file mode 100644 index 0000000..1d69cfd --- /dev/null +++ b/app/src/main/res/layout/create_edit_contact_fragment.xml @@ -0,0 +1,281 @@ + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + \ No newline at end of file diff --git a/app/src/main/res/layout/create_pin_fragment.xml b/app/src/main/res/layout/create_pin_fragment.xml new file mode 100644 index 0000000..00d1e96 --- /dev/null +++ b/app/src/main/res/layout/create_pin_fragment.xml @@ -0,0 +1,129 @@ + + + + + + + + + + + + + + + + + + + + + + + + \ No newline at end of file diff --git a/app/src/main/res/layout/decision_bottomsheet.xml b/app/src/main/res/layout/decision_bottomsheet.xml new file mode 100644 index 0000000..2769708 --- /dev/null +++ b/app/src/main/res/layout/decision_bottomsheet.xml @@ -0,0 +1,78 @@ + + + + + + + + + + + + + + + + \ No newline at end of file diff --git a/app/src/main/res/layout/done_bottomsheet.xml b/app/src/main/res/layout/done_bottomsheet.xml new file mode 100644 index 0000000..91d7c72 --- /dev/null +++ b/app/src/main/res/layout/done_bottomsheet.xml @@ -0,0 +1,41 @@ + + + + + + + + + + \ No newline at end of file diff --git a/app/src/main/res/layout/forgot_pin_fragment.xml b/app/src/main/res/layout/forgot_pin_fragment.xml new file mode 100644 index 0000000..1dd7762 --- /dev/null +++ b/app/src/main/res/layout/forgot_pin_fragment.xml @@ -0,0 +1,106 @@ + + + + + + + + + + + + + + + + + + + + + + \ No newline at end of file diff --git a/app/src/main/res/layout/how_to_set_up_fragment.xml b/app/src/main/res/layout/how_to_set_up_fragment.xml new file mode 100644 index 0000000..785610d --- /dev/null +++ b/app/src/main/res/layout/how_to_set_up_fragment.xml @@ -0,0 +1,363 @@ + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + \ No newline at end of file diff --git a/app/src/main/res/layout/location_fragment.xml b/app/src/main/res/layout/location_fragment.xml new file mode 100644 index 0000000..ba022e8 --- /dev/null +++ b/app/src/main/res/layout/location_fragment.xml @@ -0,0 +1,201 @@ + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + \ No newline at end of file diff --git a/app/src/main/res/layout/onboard_one_fragment.xml b/app/src/main/res/layout/onboard_one_fragment.xml new file mode 100644 index 0000000..de7b515 --- /dev/null +++ b/app/src/main/res/layout/onboard_one_fragment.xml @@ -0,0 +1,39 @@ + + + + + + + + + + \ No newline at end of file diff --git a/app/src/main/res/layout/onboard_three_fragment.xml b/app/src/main/res/layout/onboard_three_fragment.xml new file mode 100644 index 0000000..ad5799d --- /dev/null +++ b/app/src/main/res/layout/onboard_three_fragment.xml @@ -0,0 +1,39 @@ + + + + + + + + + + \ No newline at end of file diff --git a/app/src/main/res/layout/onboard_two_fragment.xml b/app/src/main/res/layout/onboard_two_fragment.xml new file mode 100644 index 0000000..aac2df7 --- /dev/null +++ b/app/src/main/res/layout/onboard_two_fragment.xml @@ -0,0 +1,39 @@ + + + + + + + + + + \ No newline at end of file diff --git a/app/src/main/res/layout/profile_progress_fragment.xml b/app/src/main/res/layout/profile_progress_fragment.xml new file mode 100644 index 0000000..57a6688 --- /dev/null +++ b/app/src/main/res/layout/profile_progress_fragment.xml @@ -0,0 +1,380 @@ + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + \ No newline at end of file diff --git a/app/src/main/res/layout/register_fragment.xml b/app/src/main/res/layout/register_fragment.xml new file mode 100644 index 0000000..a255c19 --- /dev/null +++ b/app/src/main/res/layout/register_fragment.xml @@ -0,0 +1,238 @@ + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + \ No newline at end of file diff --git a/app/src/main/res/layout/sign_in_fragment.xml b/app/src/main/res/layout/sign_in_fragment.xml new file mode 100644 index 0000000..037f8f1 --- /dev/null +++ b/app/src/main/res/layout/sign_in_fragment.xml @@ -0,0 +1,154 @@ + + + + + + + + + + + + + + + + + + + + + + + + + + + + \ No newline at end of file diff --git a/app/src/main/res/layout/sign_in_up_fragment.xml b/app/src/main/res/layout/sign_in_up_fragment.xml new file mode 100644 index 0000000..92f1f50 --- /dev/null +++ b/app/src/main/res/layout/sign_in_up_fragment.xml @@ -0,0 +1,67 @@ + + + + + + + + + + + + + + + + \ No newline at end of file diff --git a/app/src/main/res/layout/thank_you_fragment.xml b/app/src/main/res/layout/thank_you_fragment.xml new file mode 100644 index 0000000..e0b7cca --- /dev/null +++ b/app/src/main/res/layout/thank_you_fragment.xml @@ -0,0 +1,79 @@ + + + + + + + + + + + + + + + + + + \ No newline at end of file diff --git a/app/src/main/res/layout/welcome_fragment.xml b/app/src/main/res/layout/welcome_fragment.xml new file mode 100644 index 0000000..2dec3ee --- /dev/null +++ b/app/src/main/res/layout/welcome_fragment.xml @@ -0,0 +1,91 @@ + + + + + + + + + + + + + + + + + + + + + + + + \ No newline at end of file diff --git a/app/src/main/res/mipmap-anydpi-v26/ic_launcher.xml b/app/src/main/res/mipmap-anydpi-v26/ic_launcher.xml new file mode 100644 index 0000000..eca70cf --- /dev/null +++ b/app/src/main/res/mipmap-anydpi-v26/ic_launcher.xml @@ -0,0 +1,5 @@ + + + + + \ No newline at end of file diff --git a/app/src/main/res/mipmap-anydpi-v26/ic_launcher_round.xml b/app/src/main/res/mipmap-anydpi-v26/ic_launcher_round.xml new file mode 100644 index 0000000..eca70cf --- /dev/null +++ b/app/src/main/res/mipmap-anydpi-v26/ic_launcher_round.xml @@ -0,0 +1,5 @@ + + + + + \ No newline at end of file diff --git a/app/src/main/res/mipmap-hdpi/ic_launcher.webp b/app/src/main/res/mipmap-hdpi/ic_launcher.webp new file mode 100644 index 0000000..c209e78 Binary files /dev/null and b/app/src/main/res/mipmap-hdpi/ic_launcher.webp differ diff --git a/app/src/main/res/mipmap-hdpi/ic_launcher_round.webp b/app/src/main/res/mipmap-hdpi/ic_launcher_round.webp new file mode 100644 index 0000000..b2dfe3d Binary files /dev/null and b/app/src/main/res/mipmap-hdpi/ic_launcher_round.webp differ diff --git a/app/src/main/res/mipmap-mdpi/ic_launcher.webp b/app/src/main/res/mipmap-mdpi/ic_launcher.webp new file mode 100644 index 0000000..4f0f1d6 Binary files /dev/null and b/app/src/main/res/mipmap-mdpi/ic_launcher.webp differ diff --git a/app/src/main/res/mipmap-mdpi/ic_launcher_round.webp b/app/src/main/res/mipmap-mdpi/ic_launcher_round.webp new file mode 100644 index 0000000..62b611d Binary files /dev/null and b/app/src/main/res/mipmap-mdpi/ic_launcher_round.webp differ diff --git a/app/src/main/res/mipmap-xhdpi/ic_launcher.webp b/app/src/main/res/mipmap-xhdpi/ic_launcher.webp new file mode 100644 index 0000000..948a307 Binary files /dev/null and b/app/src/main/res/mipmap-xhdpi/ic_launcher.webp differ diff --git a/app/src/main/res/mipmap-xhdpi/ic_launcher_round.webp b/app/src/main/res/mipmap-xhdpi/ic_launcher_round.webp new file mode 100644 index 0000000..1b9a695 Binary files /dev/null and b/app/src/main/res/mipmap-xhdpi/ic_launcher_round.webp differ diff --git a/app/src/main/res/mipmap-xxhdpi/ic_launcher.webp b/app/src/main/res/mipmap-xxhdpi/ic_launcher.webp new file mode 100644 index 0000000..28d4b77 Binary files /dev/null and b/app/src/main/res/mipmap-xxhdpi/ic_launcher.webp differ diff --git a/app/src/main/res/mipmap-xxhdpi/ic_launcher_round.webp b/app/src/main/res/mipmap-xxhdpi/ic_launcher_round.webp new file mode 100644 index 0000000..9287f50 Binary files /dev/null and b/app/src/main/res/mipmap-xxhdpi/ic_launcher_round.webp differ diff --git a/app/src/main/res/mipmap-xxxhdpi/ic_launcher.webp b/app/src/main/res/mipmap-xxxhdpi/ic_launcher.webp new file mode 100644 index 0000000..aa7d642 Binary files /dev/null and b/app/src/main/res/mipmap-xxxhdpi/ic_launcher.webp differ diff --git a/app/src/main/res/mipmap-xxxhdpi/ic_launcher_round.webp b/app/src/main/res/mipmap-xxxhdpi/ic_launcher_round.webp new file mode 100644 index 0000000..9126ae3 Binary files /dev/null and b/app/src/main/res/mipmap-xxxhdpi/ic_launcher_round.webp differ diff --git a/app/src/main/res/navigation/welcome_nav_graph.xml b/app/src/main/res/navigation/welcome_nav_graph.xml new file mode 100644 index 0000000..58fc2da --- /dev/null +++ b/app/src/main/res/navigation/welcome_nav_graph.xml @@ -0,0 +1,140 @@ + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + \ No newline at end of file diff --git a/app/src/main/res/raw/done_anim.json b/app/src/main/res/raw/done_anim.json new file mode 100644 index 0000000..cd24fd4 --- /dev/null +++ b/app/src/main/res/raw/done_anim.json @@ -0,0 +1 @@ +{"v":"5.5.2","fr":4,"ip":0,"op":12,"w":864,"h":864,"nm":"@forresto/movie-to-lottie","ddd":0,"assets":[{"id":"fr_0","w":864,"h":864,"u":"","p":"data:image/jpeg;base64,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","e":1},{"id":"fr_1","w":864,"h":864,"u":"","p":"data:image/jpeg;base64,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","e":1},{"id":"fr_2","w":864,"h":864,"u":"","p":"data:image/jpeg;base64,/9j/4AAQSkZJRgABAQAAAQABAAD/4gHYSUNDX1BST0ZJTEUAAQEAAAHIAAAAAAQwAABtbnRyUkdCIFhZWiAH4AABAAEAAAAAAABhY3NwAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAQAA9tYAAQAAAADTLQAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAlkZXNjAAAA8AAAACRyWFlaAAABFAAAABRnWFlaAAABKAAAABRiWFlaAAABPAAAABR3dHB0AAABUAAAABRyVFJDAAABZAAAAChnVFJDAAABZAAAAChiVFJDAAABZAAAAChjcHJ0AAABjAAAADxtbHVjAAAAAAAAAAEAAAAMZW5VUwAAAAgAAAAcAHMAUgBHAEJYWVogAAAAAAAAb6IAADj1AAADkFhZWiAAAAAAAABimQAAt4UAABjaWFlaIAAAAAAAACSgAAAPhAAAts9YWVogAAAAAAAA9tYAAQAAAADTLXBhcmEAAAAAAAQAAAACZmYAAPKnAAANWQAAE9AAAApbAAAAAAAAAABtbHVjAAAAAAAAAAEAAAAMZW5VUwAAACAAAAAcAEcAbwBvAGcAbABlACAASQBuAGMALgAgADIAMAAxADb/2wBDAAYEBQYFBAYGBQYHBwYIChAKCgkJChQODwwQFxQYGBcUFhYaHSUfGhsjHBYWICwgIyYnKSopGR8tMC0oMCUoKSj/2wBDAQcHBwoIChMKChMoGhYaKCgoKCgoKCgoKCgoKCgoKCgoKCgoKCgoKCgoKCgoKCgoKCgoKCgoKCgoKCgoKCgoKCj/wAARCANgA2ADASIAAhEBAxEB/8QAHAABAQADAQEBAQAAAAAAAAAAAAEFBgcCBAMI/8QAQxABAAECBAQDAwkECQUAAwAAAAECAwQFEUEGITFREmFxIoGxExQjQlKRocHRMjNicgcVJENTVIKS4TQ1RGPwFiXx/8QAGQEBAAMBAQAAAAAAAAAAAAAAAAIDBAUB/8QAJhEBAAIBBAEFAQADAQAAAAAAAAECAwQREjEhIjJBQlETFFJhcf/aAAwDAQACEQMRAD8A/qgAEFSQBQEUTcFRQEFARQBFAAAAAEABRADRQ5AgoBKKgLoEEAIoAigIKAiiTMRzmY0BRj8ZnGAwf7/E24mPqxzn7oYfE8ZYO3ysWbt2e8+zCcY7W6hCctK9y2gc/wATxfjq6voLdq1Tty1li8TneY4jXx4q5EdqZ0j8Fsaa09qZ1VI6dQruW7dOtyuKKY3qnR8N/Ostw8+3i7WsbUzr8HLqrldcz466qpneZeVkaWPmVU6ufiHRLvFuWW/2ZuV+lL4rnGuHifo8Jcn1qiGkLpCyNNRCdTeW2XOM78x9HhbdP81Uz+j5q+L8xq/ZotU/6dWuCX8aR8K5z3/Waq4ozSr+/po9KIfl/wDkGaf5ur7oYleSXCv4j/W/6yU57mc/+Zd+/R4/rrMtf+tvf72PWDhX8ec7frIf1zmX+dv/AO8/rrMv87e/3Mepwr+HO36ytPEWaU/+XM+sRP5P0o4nzSn++pn1ohhCDhX8e/0v+tktcX5hT+1RZr/0zH5vqtcaXP77B0T/AC16fk1IR/jSfhOM94+W82uM8LP7zDXqfSYl9trirLLnW5Xb/mpc45CE6ekpRqbw6tYzbA3/AN1irM+XiiJfbTVTV+zVE+k6uOv0sYi9Z/dXa6P5aphGdLHxKyNXPzDsA5hheIMyw/7OKqrjtXpMMrheMcVT/wBRZt1+dOsKp014W11VJ7b0NdwvFuX3dIuxds1T9qnWPwZfCZhhMXGuHxFu56TzVTjtXuF0ZKz1L6wEEwAAAAAAAAEBQAQUAAAABBQAAAAAAAAAAAAAAAAAAAAAAD3J7tFANDQ0AA0QFQ+KgIukpp2BRAD05LoAJ6dTyWE+IKB0BOxpqpuCRz6KEgbgAB0ANNYIE2BeuwmizyiZmY0AGIzDiDL8FrFV75Sv7Nvm1rH8X4q9rGDt02aftT7UrKYrW6hTbNSvct5u3aLVPiuV00Ux1mqdIYbG8T5dhtYpuTeqja3H5tAxeNxOLrmrEXrlz+arV88tFNLH2lntqp+sNoxfGGJr1jC2LdqO8+1P6MHi8yxmLmZxGIuVxP1fFpH3PjRorjpXqFFsl7dydQjlCpq0RQeAAKEdCBJIAgRWABICCAQARUAEBAVFAEUBQB6hTM0zExMx5wA8ZHA53mGEn6PE11Ux9WufFGnvZ/BcZVRMRjMPExvVRP5NPFdsVLdwsrmvTqXTsHxBl2KimKMRTRXP1a/ZllaZiqNYccfbg81xuDmPm+IuUxH1ZnWPulRbS/6y001f+0Oro0vL+Mqo0px9jWPt2/0bNgM2weOj+z3qZq+zPKY9zPbFavcNFctL9S+/UEVrV94J+ACovoAIAqaaCgCKACAqKAB8U0BdkXQgAAD4IoCKACKAaHIANIRfcAHuD0A8yPTQAA94CL2AD3AadATTnquh90HoBpuABAaABzNCIA56hIAIAqHT0JAVDQF0NAAINUkFB8+MxljB2puYm7Tbo71SHXb6H5379qxbm5euU0URvVOjUc04xj2qMuo1/wDZXHwj9Wp4vG4nF3JqxF6u5M95aKae1u2W+prHXluuZcXYe1rRgqPlqvtVcqf1armGc47HVTF69Pyc/Up5UsaurVTFWnTLfNa/YAtUiKkAoHYEAAABQ/AAAABPcCh0AIUB6gA8UAegAAICADxUUkEABYRYQHrsEHYeixM0zE0zMTG8SkbIPGby7iXMMHFNFVcXrcfVr6/e2nLeKcDitKL0zh7navpPvc60VVfDSy+me9XY6ZiqmJiYmJ6TCuV5Zm+My+YjD3Z+T3oq50ttyvivDYjSnGx83r79afvZL4LV6a6aitu/DZx4orpuUxVRVFVMxymJ11e1DQv3oQAc0/BYOQId1AD0AA+AABoAG6LAHxDmdQNE5ctl07m4AbmgGgAGhpqeoAeZ1APiAABoAnVTzAT7tVABCe4KfE00OgJ8V0AE068xQADmBHqEwdAD3mmh7gQjTTkvTY9wJ7g07LAIp0SZiImddIjcFfliL9rD2puX7lNuiOs1To17OuKsPhfFawUfL3o+t9WmfzaVmGYYnHXvlMTcmqdo2j0hfjwWt34Z8morTxHltOb8X6a28uo8vlKo+ENTxWKvYuubmIu1V1zvVL8UbKYq16YcmW158qgLFYACgAEgAioAAAqAKAAEAIEdVA5JyF2ACCNgQUAOwkAsCR1UAAEABQAQUBQBJFQBR5BFRFAAB9uX5ri8vricLcqinemedMtxynirD4nSjGR83u9/qz72gLqqvhrdbjzWo7FRVFVMTExMT0l6cuyrO8Zl0x8jXNdre3Vzj3dm85Rn2FzKIppn5O9/h1fkx5MNqN+PPW7MBoKVwqAGgAJoKAQfgAAkKBHQDzAiDQTcF05m4fEAjQ0IAjRJ5dFATucz3ERp0A2FnqAm+qppMT5GvLl17Au59wAaehyhNAFgQBT1SFA0NzQ89AD4oAogCkABAiwAHoADzXVFFM1VTEUx1mejU8+4piiarGW86ulV2ekeidKTedoQveKRvLPZrm+Fy2iZv1xNzaiOstDznP8AFZlrT4vkrO1FM/HuxV+9XfuTXdrqrrnrNU6vzbceCtPM9sGTPa/iOl2O3kC9nQAFABAAUAAVAAAAAAIBFeVHuwIo8AAFRQRdyOoBCdlAAAAAOx2TssAioQAqAKIAoigAAAAgAAALBBABBTM0zExMxMbwIDZ8l4pvYXw2sdrdtfb+tH6t2wWMw+Nsxdw1ymuid4lyKX1Zdj8Rl975TC3JpneNqvVnyaeLeatOPUzXxZ1sYDIeI8PmHhs3tLOJ7TPKr0Z9itWaztLfW8WjeEVDRFJdAgBPeponMCFE6Ap8E08uSxyA0RdDYEjpyXRNOR2BYgDYDQ05nI5AaeZAeYGidFUE05cjRNuqgbk9OZonSNJBQAQWYTQF17nwT4roCSdDTsadgXeAANU85NPJdOYGht5GnLkaRAECc9VAfJmWYYfLsPN7E1+GNojnNU9oY7P8/sZZR4aNLuJmOVG1Pq5/jsZfx2IqvYm5NdU9I2jyhfiwzfzPTPlzxTxHbJZ5n2IzKubcVTbw0TyojfTuw0iN9aRWNoYLXm07yKivUEAAABAAFCAAASNjsRsRsC6eRp5KQPUAHgAAaAAigIQEAAAoACEgAAAoCAAoAIHQiQAABQEFAAAEUBQgEgAePIaA8BQDXdtGQcUXMPFNjMJmuzHKLm9Pr3avoiNqReNpTpe1J3h2HD3reIs03bNdNdFUaxMS/Ry3Js4xOV3tbU+O1P7VuqeU/o6JlWZ4fMrEXMPXz+tRPWlgy4po6GLNW/8A6+3YFUrzqaIoBrz6AAnmqAqRzNtegC7AAigCdF2DoAabABAAHuDY6eUAcj3BAJobej1KAb+YaEfeCaGnnzU0A+5ORougByNADlB7jQABKqqaKZqrmKaYjWZnpAK1TiPiWmxFWGwE+K7PKq5HSn083wcS8SziPHhcBVNNnpVXHKavTyarro14cH2sx5tR9avVdVVyuqu5OtUzzmUBsY0hFUReQAAAAAUSOigAAAAAACID0AAAAACAAoAAAIqLoAgQCiQoAAIAAACgAdhOy7ACKAACI9AIAD0APUBIHigAAkgAAPowOLv4HEU3cNXNFcdfPyl84d9kTt06Xw/ndrNLOlWlGIpj2qdevnDNOO2rldm5Fy1VNNdPSYnSYb5w3xFRjfDhsXMUYnT2Z2r/AOWHNg4+qroYM+/izZhBmalEAek0ADqaJooBHpoRCcunYFEX4gminuTzBZEhQAgAA08gIRdwCFRAWY12Tr3U5gR2VOup5a8wE9y7mgEAcwAflfvW8PZqu3qooop5zMyHS3rtFm1Ny7VTRRTGs1T0hz7iTP7mY11WMNVVRho5cvr+c+TxxHn1zNLs2rMzRhaZ/Z3q85YNtw4ePmzBnz8vFVBGplAUePIAAAAAAqAuyR0VAAAAABQEFAQUBBQEAAVIJAAAFAQAAAAAF0AgEAAFAQUBAAUAAAAAERQBFAUAAAAgARQAAAWKpifFTyqieoA3ThfiOLsU4TH1RFccqK539W3w41u3HhfiPw+HCY+ryouT7uUsebD9qtuDP9bNzCNJjWOk9jXRkbSFlAFRQAEA5nT0XZOmgKeqR5nTqAKAHqnZeQAigAAHPU8wA5gAke5epzA3nqJtG0r7gAebldNuiquuqKaaY1mZnSIgHm9dos2qrl2qKKKY1mZc74jzy5md6bdqZpwtE+zH2vOX6cTZ5VmN2bWHmacNRP8Av858mAbsGHj6rMGfNy9MIIsS0sgAAACAAAAAAoACKgAKCAAoAIAAACgAAAkLGxHUBAAAAVFIBAAUQBY6gcgAABI6EcgAAAAUAAAAAEUgBBUAAAAAVAFEAURQAAQAG48KcQeGqnBY2rryt3J+Etzcc7N14Tz/AOU8GCxtXtRGlu5M9fKWPNh+1W3Bn+tm3KgyNqmiAKBoAIAqHTSAFE6LoCaeQuiaAKnU05goa80BeYdSAPSQ2OwHvRZInoCac1EiNAGicWZ7OJuVYTCV/QUz7VVP1p/R93GGezbirA4OvSueVyuNvKGkNeDD9rMWozfWr0ijYxgAPIA8UAEAAAAFAAAQAAFgEAAAAAAAAFAAAEFBBUAAAAAAAFABFBI6KeQCAAAACgIKAgoAAAAAioCosIACgkbHYjYjYAAAAFEhQAACJmmYmmdJjpIA33hPPfnluMLiavp6f2ap+vH6tn0cdtV12rlNduqaaonWJh0jhrOKMzwsU3J0xNuIiunv5sOfFx9UOhp82/pszSAzNSiKAHvNAOpPY6SdQQ6E/cbaAAugIdfQ/BdANOZ6HUA5nM6mgBMCghMHvNAGB4pzmMuws2rNX9puRMU/wx3ZHN8wtZbg6r93ntTTrzqns5fjcVdxuKuX79U1VVzvsvwYuU7z0z58vCNo7fjVVVXXNVUzNU7yhA6Dm7gAIAAAAAAAAAAACgAgAKAACAKgBKpIAAAACgAAAAAioAqKgAAAAKACQqQoBuAAIAAAAAACgAAAgAAAAAKigIqAKioAAAAAAA+jL8VdwWLt4izMxXTPTv5PnHm2/gjx5dYynMLWZYKi/anrGlUb0z2fa5hw/mteVYyK51mxXGldP5umWbtF61RctVRVRVGsTDn5sU45dTDl/pD2n3qKVwAB1Dt0AE/BQEXmfFNAN1hF76Adk0XQBPeqTBr9wKaAA83K6bdFVdcxFNMazM7Q97NM43zfl/V+Hq59bsxP3QnjpN7bQhkvFK7ywfEWa1ZnjJqiqfm9HKimY/Fi069eiR0h061isbQ5drTad5AR6gAAAAAACgIKAgoCCgAAIAAAASAJGxGxGxGwKKAgoCCgAAAAAAIKAAAgAAoCCgIACgAgoCAACgIKAgoCCgIAAACkAAioAACRsRsRsRsCigIKAgoCAANs4NzmbVynAYiZ+Tq/dzO09mprRVNNUTEzEx0lC9IvG0p47zSd4dkGC4VzaMxwfgu1fT2tIqjvHdnXNtWaztLq1tFo3gEEUlIRQA0NAOgnXlJoBoeZy2XQEgPNde4H4JPmpPvAQ3+JVVFNFVVc6UxGszPYGN4gzOnLMvruxMTeq9m3T3n/AIcwuV1XLlddczNVU6zM7yyfEWZVZlmFdcT9DR7NuntDFOhhx8I3+XNz5OdvHQii9nQUBAAAAAAAAAAAAAAEjrBudh7CwEA8AAAAAAAAAAAAAAU6AAAAAAAAACAAAAhD0AgAAKCKhoCiaKCAAAAAAAAAAoAAAAAAAIAAAAACop2BAAfZlWOuZfjaMRbnnHKY2mOzqeExFvFYa3ftVa0VxrEuPw23gnNfkr04G/V9HXOtvynszajHvHKGvT5OM8ZbwHXoR1YW8VFgAAEUAICFB57djoqdoBY9EjY8tl3AapxvmvyFiMDZq+kuRrXPant72x47FUYTC3L92dKKKdfXycqx2KrxmMuX7s61Vzr7mjT4+U7yzajJxjaH4AN7nIAAAAAAAAKAgoCCgIKAhSp6AB2QAAAUBBQEFAQUBBQEFAQAFAAAAAAAAABAABQEFlAAAAAWOoQdgANwQAAAAAAAAAAAAUBBQEFACABAASNljYjYjYAUBAAHq3XVbrpqomYqpmJiY2lE3B1Hh7Mqcyy+m50uU+zXHaWUcz4XzOrL8yp8U/QXPZrjbyl0umfFGsdJc7NThZ1MOTnU0NBVK40AANABF9RAD8FTQDdTR8ebY2nAZfexFf1aeUd52exG87Q8mYiN5apxvmfjv04G3PsUe1c077Q1F+l+9Vfv13a51rrnxTPm8OnSnCNnJyXm9t5TXzFE0EAAFAQUBAAAAAAAAAAUACEUBAAAAAAAAAAAAAABUAABQAAAAAAAQAAAAAAAAAAAEgIAVSNjYEABUUjYEFQFRSAQAAAAAAAFAAAABAAAUAEABHReDsz+eZfFm5P01nSmfTZzpksgx05fmNu7rpaqnSv05Ks2PlVdgvws6mrzRVFdFNVM6xMaq5rqBuaczTmC/cAAAABr2AaLx1j/AJXE28Jbq9i37VcR3bjmOLowWCvYi5OkUU6+/ZyjEXar+IuXa51qrqmqZadNTe28smqvtHGH5gNzAgAAAAAAAAAAoCCgIKAgoAAAACAACgIAAAAKAgoCCgCKgAABoKAIoAAAAIAAKAgoCAAAoIAAigLAigIqAAAAAKkKCAAAAAAAAAAoAIACLHQI6D0AHgAAADofBeYfO8ujD3J+lsez607Nh0cw4cx05fmlq7M/R1exX6S6hTMVUxMdJc/PThZ09Pk5VBBQvU0RQORoAAPNyum3bqrrnSmmJmZ7RANP48x37rA0T/Hc027R8WmR1fXmeLrx2OvYivX251iJ2jaHyunirwrEOVmtytMn/wBqAsVIAAABGx2RQI2I2SNiNgUAAAAAAAAAFAAA1AABAAVFIBAAAAAAAAAAAAAAUAAAAAEICAAAAAAAAAAAAAAAUAAABFASOqpHVQEVAVFAQAFRUAAAABAAegAE6KAgoCCgDpPCOPnG5RRFc63bXsVefaXNmf4Mx3zXNIs11aW70eH37Kc9OVd1+nvxu6Jobr2RznTNDTmALAcgBr3GuN+a5V8jTOld+fDHpHVsTnHGWMnFZvVbirW3ZjwRHnv+K7BTldRqLcaMBEaCmrouYCclBAAUAHkAFAAAAFAQUBBQEFAAAAAAAQAAAAAAAAAAUBAAAABQAAAAAEAAAAAAAAAAAAAAAAAVAFEAUAEFAQAAAAAAAAAAAAAAAAAF7CAKIsyAtqubdymunlVTMTHlLyA61lOLpxmX2b9P16YmY7TvD62ocAYzxWb+Fqn2qZ8dMeW7b3LyV42mHWxX51iUOh5qgsRUXcH4ZhiacJgr2IrnSLdMz73Jbtc3btdyudaq6pqmfVvPHuLm1gLeHpnndq1n0jRobbpq7Ru5+qvvbiIDUygAAAKADyACgAAAAAgAKACAA9AAAnkChoAgAKigIACooCAAAAkbEbEbEbAoAAAKAAAAACAAqKSCAACoAAAAAKAgoCAAAAvRFQF0NAARUAAAAAFAQAAUBAAAAAAI2I2I2I2BUVIA5AAyXDWK+Z5zh7kzpRM+Gr0l1NxqNYnWHVcixXzzKcNe19qaIir1jlLHqa9WbdJbur7wGRtUH537lNmzXdr5U0UzVPuDpz3jPFRic5roidabMRRHrv8AiwD3iLtV2/XcqnWa6pq++XiHVpXjWIce9uVpkASROgKCAAAAkbEbEbEbAsbBGwAAAAAKAgAAoCAAp2AEAAAAAAAAFAQUBAAAAAABQEFAQUAPMAQAAUBBQEAAABAAUAAAAAEgAFAAABUhQEAAAAAAAAAAAAAAABUUBAAVFhAeohuvAWK+iv4WZ5UzFdPvaSzHCmK+bZzZiZ9mv6Off/8AyFWWvKkrsN+N4dMElXNdQYPjHEfN8juRE6VXKqaI+/WfwhnGl8f4n6XC4eJ5RE11fl8JW4Y3vEKs07UmWnAOk5QABHWAgAAAABICAF3INyAAAAAAAAAAAAAUAEAAAAAAAAAAAAAAUAQAAAEABQAUAEAAAAAAAAWOqLACKAgAAoCAAAAkbLskdVnoCEBAKAAKAgoCCgIKA8xsRsRsRsCgAAACgIKAgqdgAAHq1XNu7Rcp/aoqiqPdOryA6/hbtN/DWrtP7NVMS/ZgeDcR8vkdqmZ52pmhnnKvG0zDsUnesSOZ8X3/AJfPcRz5W9KPTSHS6piKZmekRq5Bi7s3sVeu1TMzXXNWs+bRpY9UyzaufTEPyCOp2bWAAAgIAAAAAQjYjYjYFjYjYjYjYAUBBQEFAQUBBQEFAQUBBQEFAQUBBQEFAQUBBQEFAQUBBQEFAQUBBQEFAQUBBQEFAQgIBAAUAAAAAFRSAeY2OxGydgIWNiCAeggBAAAAAAAAAABUAAAAAAAAAAAABuX9H9/T53h5nn7NcfCfybm5xwZfm1ntunXlcpmmfj+To7n6iNrulpp3o+DO78YfKMXcnlpbqiPWY0cqq6uicb3vksiqpidJuV00/jr+TnUrtLHp3Z9XPq2AGplAAUAEAAABAAUAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAEABQAAAQAHoAAAEAAFAQUBAAVFAQAAAAUBBQEFAQUBBQBFQAAAUBBQEAAAAVAH2ZTejD5phbs9KbkOsw43z5adYdcwFyLuDs3I+tRE/gx6qPMS3aSe4az/SFc+gwdqd6qqvuiP1aTPSG08f3fFj8Na+xbmr75/4asuwRtSGfUTveUAXKQAAUBBQEFAeY2I2I2I2BY2IWNiNgQUBBQEFAQUBBQEFAQUBBQEFAQUBBQEFAQUBBQEFAQUBBQEFAQUBBQEFAQUBBQEFAQUBBQEAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAABXT+Fq5ryDBzO1Hh+7k5g6DwLd8eTzT9i5Mfn+bNqY3ru1aWdrNa41r8Wf3Y+zTTH4RLB7MpxTV8pn2LntXFP3RDF7Qux+yFGT3ygCaAAAAAAAACAAoAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAoCCgIKAgAAAAAAoCCgIKAgoCCgIAAAAKAgoCAAAAAAN4/o/r/s2Kt/xxP4f8NHbb/R9X/a8XT/AAUz+P8Aypz+yV+n98MBnlfjznGT/wC2r3c3wPpx8+LG4if/AGVfF889VteoVW7kAeogAAoDzGxGxGxGwKKA8xsRsRsRsCxsQsbEbAgoCCgIKAgoCCgIKAgoCCgIKAgoCCgIKAgoCCgIKAgoCCgIKAgoCCgIKAgoCCgIKAgoCCgIAAAAAAAAAAKAgAAAAAAAAAAAAAAAAAAAAAAAAADZeAq/Dm1yn7Vqfya0z3BFWmfUedFUfBXl9krcPvhhb/8A1Fz+efi8LXOtcz5onCpAHoAAAAAAAAgAKAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAACoqQAAAAAAAAAACoqQAAAAAAAAAAAACoqQAAAACQACigIACQzvBn/frP8ALV8GChnuDP8Av1n0q+CGT2Stw++GEq/bn1eXuuNLlUT1idHlKFSCj0QUBBQEFAQUB4FAUUBBQEFAQUBBQEFAQUBBQEFAQUBBQEFAQUBBQEFAQUBBQEFAQUBBQEFAQUBBQEFAQUBBQEFAQUBBQEFAQUBBQEFAQUBBQEFAQUBBQEFAQUBBQEFAQUBBQEFAQUBGc4M/7/Z9Kvgwe3/3kzfBn/frH8tXwQyeyVmH3wxWNjwYu9Ha5V8X4vrzejwZri6e12r4vl7JR0hbtAHrwFAQUBBQEFAeYI2I2I2BY2OyxsRsCCgIKAgoCCgIKAgoCCgIKAgoCCgIKAgoCCgIKAgoCCgIKAgoCCgIKAgoCCgIKAgoCCgIKAgoCCgIKAgoCCgIKAgoCCgIKAgoCCgIKAgoCCgIKAgoCCgIKAgoCM/wTT/+8o8qKmAbLwHb8Wb11fYtz8YQy+yVuH3wx3EtHyeeYyO9fi+/SWLZ3jO34M+vTtVTTP4QwW5j81hHJG1pAE0AAAAAAAAEABQAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAG2f0fU/wBrxVXaiI++Wpt2/o+t/QYq5/FFP4Ks/sldg98Ph4/t+HMMPc+1b0+6Wrt1/pDt/QYO52qqp++I/RpRg80h5njbJIAtVAoCCgIKAgoDzGxGxGxGwLGxCxsRsCCgIKAgoCCgIKAgoCCgIKAgoCCgIKAgoCCgIKAgoCCgIKAgoCCgIKAgoCCgIKAgoCCgIKAgoCCgIKAgoCCgIKAgoCCgIKAgoCCgIKAgoCCgIKAgoCCgIKAgoCOg8C2/Bk01/buT+jn3/wB8HTeFqPk8hwnnGv3s+pnarTpY3u+bjm18pkk1f4dymr02/Nzt1XPbXzjJsZR3tVT90a/k5U80s+nZ7q49USANLKAAAAAAAAgAKAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAACAAoAAAAAAAAAAAAAK63gLcWsDh7cRpFNFMfg5dlVn5zmWGtfarp+7V1mmI0iI6Qx6meobdJHcpVTFVFVNUaxVGkw5DibfyOIu25jSaKpp09HX4cy4ssfIZ7iIjpXMVx74/V5pZ8zD3Vx4iWIAbWEAAABOxAAoAJ2DsAsbEbEbEbAAAAAAAkbEbEbEbAoAAAAAAoCCgIKAgoCCgIKAgoCCgIKAgoCCgIKAgoCCgIKAgoCCgIKAgoCCgIKAgoCCgIKAgoCCgIKAgoCCgIKAgoCCgIKAgoCCgIKAgoCCgM3wda+Vz6xVPSimavwdJpaV/R/h9a8TiZ05RFuPjLdaXP1E732dLTRtRYaRx/hpi/hcRERpVE0T7ucfFu8MFxjhov5Jcq09q1MVx8J+KGGdrwnmrypMObR0VIV03KQAAAAAAAE7HYAWAgAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAB6t0zcuUUU85qmIgHRuDLHyORWqpjSq7M1yzsPwwdmMNhLVmmNIopil+0OVed5mXXpG1YhX5YqzTiMNds1xrTXTNM+9+k9YWEYSmN3HbtE2r1duvrRVMS8M3xhg/mud3Zpj2LsRcjTz5T+MMI6tZ5REuRevGdlASRQAAAAAEjqgA9AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAMvwnhPnOd4eJj2bftzr5MQ3X+j/C6UYjE1R1nwU+m6rNbjSZW4a8rxDb91Sequa6qLCT/wAruDU+P8HNeDs4umP3NWlU+U6fo0WHW81wsYzAX7E6e3TMRr32/HRyaqiaKqqao0qpmYmG7TW3rs5+qrtbf9QBpZQAAUBBQHgFBRQEFAQUBBQEFAQUBBQEFAQUBBQEFAQUBBQEFAQUBBQEFAQUBBQEFAQUBBQEFAQUBBQEFAQUBBQEFAQUBBQEFAQUBBQEFAQUBBQEFAQUBBQEFAQUBBQEFAQUBHU+H8J8zyjDWtPa8Piq9Z5y57kGDnG5th7WnsxPiq9I5/k6nEco06Mept1DbpKd2IjopPUlkbUjlssJpzUBzXi7B/NM5uzTGlF76SPz/F0prfHOC+cZZTiKadarE6zP8M9fyXYLcbqc9OVHPlSFdFy0AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAABAAUAAAAAFBaKZqqpppjWZnSIBuPAODnw38ZVHKfYp/P8m5R0fFlGEjBZdYsU/Vp5+c7vtczLflaZdbFTjWIBIXVWsNE17qAPzvWqb1m5buRrRXTNM+j3+Cg5DjsLVg8Zdw9yOdudPV+Db+PMB4LlrG0xyq9ivTadpajpydPHblWJcnLXhaYQBYrBQEFAQUBBQEFAQUBBQEFAQUBBQEFAQUBBQEFAQUBBQEFAQUBBQEFAQUBBQEFAQUBBQEFAQUBBQEFAQUBBQEFAQUBBQEFAQUBBQEFAQAAAAUBBQEFAQUBBQEFAQUBGe4OwPzrN6a6o+js+3PrswLo/COA+Z5TTcrj6W97c+mnKFOe/Gi/T05XZ2Z7KDnOmJ6hHlpqAp6Qbgabh5gPjzjBU5hl97D1aR445T2naXKK6KrVyu3XGldE+GqO0uyNA45y/5vj6MXbp+jvRpV/NDVpr7TxZNVj3jk1kIlG1gAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAADuAAAAAAAAAAAAAAAAAMjkOAnMcytWdPYifFXPlDqdFMUURTTGkRGkNa4Jy75vgfnVcaV3uceUNmc/PflZ09PTjXf8AQCVC9JhRPUFSdN19UBYDtqAPhzvA05jlt6xP7UxrRParZ9w9idp3eTG8bS47XRVauVUVxMVUzpMf/ejy2fjjLfkMZTjaKforvKvyq0/Rq7p0tyru5N6TS20gCaAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAyGQ4GcwzK3ZiPZ18VXlEMe6DwZlvzXBfOLkfS3tJjyp2VZr8KrcNOdmw2rdFq1TbtxFNNMaREPYOa6qRC+oAmnNT3GnYCASNwI6aLB70BdAjoA+XMsHRj8Fdw9zlTXGkTpzidpcpxVivDYi5ZuxpXROkw7A0/jrK/FTGYWo506U3NO20tGnycZ2ll1OPevKGlBGw3ueAAAACgIKAgoCCgIKAgoCCgIKAgoCCgIKAgoCCgIKAgoCCgIKAgoCCgIKAgoCCgIKAgoCCgIKAgoCCgIKAgoCCgIKAgoCCgIKAgoCCgIKAgoCCgIKAgoCCkazMRTGsz0iPcDKcNZbOZZlRRVH0NHtXPTs6fTEU0xTTGkQxHC+WRl2XUxVGl657Vf6Mw52a/Ozp4KcanWRU0Ur00XQANAOYJryIjTlBpzg9wKck9JXp1A15GkBEgPF23Tet1UXIiqiqNJiez2A5VnmW1ZZmFyzOvhn2qJ70vg0dM4myunM8BMUx/aLcTVbn8nNK4miuqiqJiqmdJh0cWTnVy8+Phb/AIkJ2FXKUAAAAAAABAAUAEABQAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAQAFAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAABWzcGZT85xXzy9T9FanSnzqYPLcHcx+Mt2LUe1VPOe0d3UsBhaMHhLeHtRpRRGkM2oycY4x206fFynlPT6IIBhdEI27hIEbCQuwBIoPMwokeXQF0Reh6gdtZI7kQAGh6gDR+Ncn+SuRj8PT7Fc6XIjae7eH53rVF61Xau0xVRXGkxO6eO80ndXkpF42ceGSz3LKsqxtduqNbc86Ku8Ma6cTFo3hyrVms7SAPXgAAAAAAAAAAAAAAAAAAAAAAAAAAAAKAgoCCgIKAgoCCgIKAgoCCgIKAgoCe4UBBQEFAQUBBQEFAQUBBQEFAQUBBQEFAQUBBQEFAQUBFhG0cG5POKvxjb9P0NE+xE/Wq/RC94pG8p0pN7cYZzhDKfmGC+Xu06Yi9ETPLpHZsIOZe02neXVpWKRtAeh6GurxJF25IsdQDl0PiQB1DXU7gmiwAHoGhuAAAHVNI5aAsHvI8jTmDHZ5ltGaYGqzXpFcc6K9P2ZcwxNi5hr1dm9TNNyiZiYl2BrnFuSfP7PzmxGmIt0zrH24aMGXjPGWbUYeUbx257/8ASp0nSrr9w3ucIpGwIACopGwIACopGwIAAAAAAAAAAAAACopGwIAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAqAKD9cJh7uKxFuzZpmquudIP8ApHnw+zI8ruZpjYt08rdPtXKu0aunYexbw1mi1Zpim3RGkRG0PjyTLbWWYKizRETV1rq051SyLnZsnOXUw4uEB0PeKVwfEAAAAJATVZiCOQGh6m4Cdd1jYPcBuBoBGwAASAQdQBpXGOQ6V1Y/CRrTPO7REdP4oae7JVTFUTExrE7NA4ryL5jdnFYWn+zVzzpj6k/o2afLv6ZYdRh29dWtLyQa2MAAAAAAABI2I2I2I2BRQEFAQUBBQEFAQUBAAAABQEFAQUBBQEFAQUBBQEFAQUBBQEFAQUBBQEFAQUBBQEFAQUBBQEFAQUB5jYjYjYjYFFAQUBBQEFI6xALRTVXXTRRTNVVU6REOicL5JGXYf5S9TE4m5zn+GOz4+EsijDRGMxdP09UexTP1Y7trYs+Xf01btPh29VgDRlbCQAJOZEAKhsAAcgA0I9AA3OoAAAaABp5AABoB6AAPzvWqL1qq3dpiqiqNJiekv0NAc14kyOvK7012YmrC1TrTVvHlLBw7DibFvE2K7N6mKqK40mJc44iyW5lWJmadasNXM+Crrp5T5t2HLy9M9ufnw8fVHTDANLKqKgAAKioAAAAAAAAAAAAAACoqAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAKgCtv4TyCaqqcZjaPZjnbomN+8vz4W4fm9VTjMbTpbjnRRMftT3bvTEUxERyiGTNm+tWzT4PtZ6iNIAY240AA6BoAEAAeoAaAAQAASsdE9AO2hpAcgOhPKQ0AiD0PQgA6dTkaAGgAGwbgPxxeGtYuxXZxFEV26o0mJfsA5ln2S3cqvzMRNeHqn2a+3lPmw7sGKw9vFWarV+mK6KuUxLnXEOR3MrvTXRE14arpV9nyluw5+Xps5+bBx8x0wgDSygoAioAAAKAgoCCgIKAgoCCgCKgAAAoCCgIKAgoCCgIKAgoCCgIKAgoCCgIKAgoCCgIKAgoCCgIKAgoCCgIKAgoCCgIKR10BG18L8PTfmnF46nS1HOiifrec+T3wvw5NyqnF4+nSiOdFqd/OW6xERTERGmnLkyZs31q2YdP9rLTERTEUxpEdIUNGNuRQAAkCNjTmKCdAnkTzA85ABeyBMAAaAcoNAgAiCT3gAbgBuABJt1APUADbkGnQDeFSDpAK/O9bovW6rd2mKqKo0mJ5xL2A59xJw7XgapxGEia8NrrVG9H/AA1t2SYiY0lpfEvDE0TVistp1iedVmPy/Rsw5/izDn0+3qq1AWqJpmYmNJjrHZ5a2NUAAAAAAAAAAAAABAHj0ipA9AAAAAAAAAAAAAAQAAAFAAAAAAAAAAABAAUAAAEABQAAAAAFQBQfph7F3E3qLVi3NddU6REA/Ommqqummj2qu0dW8cNcN/ITTisdGtzrTbnpT6vr4c4et5dRTexGleKnnrPSj0/VsLFlz7+Kt+HTxHmx0BPJlaxToAqAAAAEnID3BIAB0gCeXM+IaAdYCAAAFTuAAi/eB6qnoAHuOoAdND1AFTdQTQVNgOkcggkDYnoLHQGuZ/w5ax+t7CxRaxG/LSK2h4rD3cLeqtX6JouUzpMS6/ox+b5Vhs0seDEU+1TzprjrTLRizzXxPTNm08X817cpGUzjJsVldf0tM1WtrlPSfXsxbdExaN4c+azWdpAHrwFAQUBBQEFAQUBBQEFAQUBBQEFAQUBBQEFAQUBBQEFAQUBBQEFAQUBBQEFAQUB5ABRQEFAQUBBQEFAQGx5BwzexvgvYyJtYfrEa+1V+kI2vFI3lKtJvO0MXlOWYnM73gsUaUxPtVz0pdDyXJ8PllmIt0xN6Y9ques/8PswmFs4SzTasURRRHKIh9EMGXNN3RxYIp2gdT0UrwiNCDQANAANCAANIA9QPQA0AD4AoJpobiggaHqB71QAIAA0CQDr0NjpAASQAAAEkAQEKCR0CNOQBIqacuQLCG4Dxds0XqJou0xVTPWJjk03POFKrcVX8s1qjrNmesekt1OadMk0neFd8cXjaXHa6K7dc03KZpqjrE9Xl07OciwmZ0zVcpii9tcpjn7+7Q81yXF5bX9LR47f+JRGsN2PPW7BkwWp5+GNQFygAAAAABRAFABAAAAQAFAAAAABQAQAAAAAAAAAFABAAQAFAAABQAAAAAQAFABNH74PCXsZfptYe3VXXVOnLb1ZrJeGsTjfBdxH0FmeftR7U+5vWAwGHwFmLeHt00xvO8+ss+TPFfEdtGLTzfzLC5BwxZwXhvYvS7iI5xGns0/q2OI06coUYrXm07y31pFY2gDQRTTmoABoAAT5AevU0CegHQCACOQSAaGwCoEQAAAAAbm55ABppoeYKmqppzANiQA9FTqAEdiANCFkBPiEdCQDoAGgEdAOpzUBICAD8nmuim5TNNdMVUz1iej0A1POuErd2Zu5dVFuqec26unu7NMxeFvYS9NrEW6rdcbTDr758Zg7GMtTbxNqm5T5x0aMeotXxPlmyaatvMORDa824RvWvFXl9XylP+HVymPRq921dsVzTeoqomNphsrkrbphvjmk7S8AJoAAAAAAAAAAAAAoCAAAACgIKAigCAACgIKAgoCCgCKgAAAAAoCCgIAAPpwOAxWNu+DDWprnv0iPe3HKOE7VnSvH1fLVfYj9lXfLWna3HhtfpqmV5Tisxr0w9HsxPOueUQ3fJeG8LgPDcuxF7ER9arnEekM5bt0W6Ipt0000x0imNIe2PJntfw249PWnmUU6mihoEXqAaAAGh0NQD4htyAiCQA7mgAHQAAjU6ATyDTSAADcANNAASNuWi7AB8DYDdUJAJVI6cgIjseoAbEBPmAEdAFTRUA6dA56AEk9JINwPIDmAs9ABJIADbkQAHU9CCAHx5hluFzCjw4q1TVO06aTHvfYPYmY6eTET20XNOEL9rxV4CqLtH2KuVX6S1q/Yu4e5NF6iqiqNph1+HzY3A4fG2/k8TapuRtrHOPe0U1Ex4sy30sT5q5GNzzPg/rVl93n9i5+UtWxuX4rA1zTirNVHn1j72quWt+pZL4rU7h8oCxWAAAAAAAAoAAAIAAAAACgAgAAAKAAACAAAAoAAeoAACDKZdkWOx/h+SteG19uuNI2bVlfCWFw+leMqm/cjbpSqtmrVbTDa3UNMwOAxWNu+DDWq6vPaG15VwfRRpXmFfylX+HRyj3y2uzat2qIptURRTG0RpD9GW+otbrw2Y9NWvmfL8sNhrWGtxRYopopjpFMaP1Bnmd2iI2DoA9WRPcAEHp0PQANACOcHT0ORH3AeRAABoAuggAQehyA6EcyDQAWDoCKhAGh2PcAHTyg05KBoJ0AFQ+8AEBQADQABUAD0UED0AFhPiAKGwGyABCp0ADcAOnRSE9QWAlAX0RUkD1ea7dFyiaa6aaqZ2qjWHtAa/mHCuAxWtVqKsPcnejp9zWcw4WzDC87VNOIo70dfudGSOq6ma1VF9PSzj121ctVzRdoqoqjaqNHnR1zF4PD4unw4izRcj+KGDxnCOCuzNWHrrsVT2nxR+LRXU1ntmtpbR05+jYcZwpj8NrVa8OIp/hnSfuYW/hr+Hrmm/ZuW6o+1ToujJW3UqLY7V7h+ACaAAAACgAgoCCgIAAKAgoCAAAACgIKAgAA+vB5ZjcX+4w9yuO+nKGdwXB2JuaVYq7RZp3iPan9Fdsla9ysritfqGrvowuCxWL5YazcufyxydAwXC+XYWmPHbm9X9qv8ARmrVu3aoim1TTRHamNIU21UfWGimkn7S0bAcH4m5pVjLsWafsU85/Rs2XZDgMDTE0WYuV/br5yywz2zWt20UwUr1CaRHSOXkoKlwB6AAAAAAbgBobAAoIKaggAEnqHfQDXlyDTuAB6qCdYFSOmoKmgABuaRIAAHSAAVA0AAA77Abzp1A6AAB5gHVUiADQ6qmgAHoAGnQ0APQ78jQDYJOYAaHuA0AAOh6AAqTsC8kAAIIADc3AkFBJea7dFymablFNVM7TGr0Aw+L4dyzEzMzh4t1fatz4WHxXBlM0/2XEzHaLka/Bt4srlvX5VTipbuHOcRwpmdqNabdFyP4a/1YvEZfi8PMxew92jTlzp5Oti2uptHcKp0tZ6lxudY5TGiS67dweFvfvcPaq9aYY6/w1ld7+4mjnr7FUwsjVRPcKp0k/EuZjfLvBmEq/d37tH3S+S7wVV/c4yP9VCcZ6T8q502SGnDZbvB2Op/YuWa/fo+erhXNaf7iifSuE/60/UP43/GCIZWrIM0p/wDDue7SX41ZNmNH7WEu/wC1LnX9R4Wj4fCPr/qvHf5O/wD7JT+rMdvg7/8Asl7yr+nGfx8g+z+rMb/k7/8Ask/qzHbYO/8A7JOVf15xt+PjH3UZRmNX7ODvf7X0WuH80uf+LXH806I86/r3hb8YkZ21wpmlX7Vuin1rh9drg3GVfvL1qj8Xn9afqcYbz8NXG6W+C6P7zFz/AKaH12ODsDR+8uXrnv0Q/wAiiUabJLQHqmmqr9mmZ9I1dPsZFltnphLczG9Uavvt2LNunw2rVuiI2ppiFc6mPiFsaSfmXL8Pk2Y4jnbwtyfOY0+LKYXhHMLn76qza/1az+DoMcoVXOptPS2NLWO2qYXg7DURHzm/cuTvFPKGZwmS4DCeH5HD0eKPrVe1P4sloaKpyWnuVsYq16h5iIiNIiIhT4CCw5mgAB0UE0A9AAO4G4KCGgbgRppyNF96bgacgmAANOxoB8RUgAiAjzAkCfIAOXSAAJj0AAAOp6kmmsAb8g6HoAHLY05dvQA15HoaA//Z","e":1},{"id":"fr_3","w":864,"h":864,"u":"","p":"data:image/jpeg;base64,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","e":1},{"id":"fr_4","w":864,"h":864,"u":"","p":"data:image/jpeg;base64,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","e":1},{"id":"fr_5","w":864,"h":864,"u":"","p":"data:image/jpeg;base64,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","e":1},{"id":"fr_6","w":864,"h":864,"u":"","p":"data:image/jpeg;base64,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","e":1},{"id":"fr_7","w":864,"h":864,"u":"","p":"data:image/jpeg;base64,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","e":1},{"id":"fr_8","w":864,"h":864,"u":"","p":"data:image/jpeg;base64,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","e":1},{"id":"fr_9","w":864,"h":864,"u":"","p":"data:image/jpeg;base64,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","e":1},{"id":"fr_10","w":864,"h":864,"u":"","p":"data:image/jpeg;base64,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","e":1},{"id":"fr_11","w":864,"h":864,"u":"","p":"data:image/jpeg;base64,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","e":1}],"layers":[{"ddd":0,"ind":1,"ty":2,"nm":"fr_0.jpg","cl":"jpg","refId":"fr_0","sr":1,"ks":{"o":{"a":0,"k":100,"ix":11},"r":{"a":0,"k":0,"ix":10},"p":{"a":0,"k":[432,432,0],"ix":2},"a":{"a":0,"k":[432,432,0],"ix":1},"s":{"a":0,"k":[100,100,100],"ix":6}},"ao":0,"ip":0,"op":1,"st":0,"bm":0},{"ddd":0,"ind":2,"ty":2,"nm":"fr_1.jpg","cl":"jpg","refId":"fr_1","sr":1,"ks":{"o":{"a":0,"k":100,"ix":11},"r":{"a":0,"k":0,"ix":10},"p":{"a":0,"k":[432,432,0],"ix":2},"a":{"a":0,"k":[432,432,0],"ix":1},"s":{"a":0,"k":[100,100,100],"ix":6}},"ao":0,"ip":1,"op":2,"st":1,"bm":0},{"ddd":0,"ind":3,"ty":2,"nm":"fr_2.jpg","cl":"jpg","refId":"fr_2","sr":1,"ks":{"o":{"a":0,"k":100,"ix":11},"r":{"a":0,"k":0,"ix":10},"p":{"a":0,"k":[432,432,0],"ix":2},"a":{"a":0,"k":[432,432,0],"ix":1},"s":{"a":0,"k":[100,100,100],"ix":6}},"ao":0,"ip":2,"op":3,"st":2,"bm":0},{"ddd":0,"ind":4,"ty":2,"nm":"fr_3.jpg","cl":"jpg","refId":"fr_3","sr":1,"ks":{"o":{"a":0,"k":100,"ix":11},"r":{"a":0,"k":0,"ix":10},"p":{"a":0,"k":[432,432,0],"ix":2},"a":{"a":0,"k":[432,432,0],"ix":1},"s":{"a":0,"k":[100,100,100],"ix":6}},"ao":0,"ip":3,"op":4,"st":3,"bm":0},{"ddd":0,"ind":5,"ty":2,"nm":"fr_4.jpg","cl":"jpg","refId":"fr_4","sr":1,"ks":{"o":{"a":0,"k":100,"ix":11},"r":{"a":0,"k":0,"ix":10},"p":{"a":0,"k":[432,432,0],"ix":2},"a":{"a":0,"k":[432,432,0],"ix":1},"s":{"a":0,"k":[100,100,100],"ix":6}},"ao":0,"ip":4,"op":5,"st":4,"bm":0},{"ddd":0,"ind":6,"ty":2,"nm":"fr_5.jpg","cl":"jpg","refId":"fr_5","sr":1,"ks":{"o":{"a":0,"k":100,"ix":11},"r":{"a":0,"k":0,"ix":10},"p":{"a":0,"k":[432,432,0],"ix":2},"a":{"a":0,"k":[432,432,0],"ix":1},"s":{"a":0,"k":[100,100,100],"ix":6}},"ao":0,"ip":5,"op":6,"st":5,"bm":0},{"ddd":0,"ind":7,"ty":2,"nm":"fr_6.jpg","cl":"jpg","refId":"fr_6","sr":1,"ks":{"o":{"a":0,"k":100,"ix":11},"r":{"a":0,"k":0,"ix":10},"p":{"a":0,"k":[432,432,0],"ix":2},"a":{"a":0,"k":[432,432,0],"ix":1},"s":{"a":0,"k":[100,100,100],"ix":6}},"ao":0,"ip":6,"op":7,"st":6,"bm":0},{"ddd":0,"ind":8,"ty":2,"nm":"fr_7.jpg","cl":"jpg","refId":"fr_7","sr":1,"ks":{"o":{"a":0,"k":100,"ix":11},"r":{"a":0,"k":0,"ix":10},"p":{"a":0,"k":[432,432,0],"ix":2},"a":{"a":0,"k":[432,432,0],"ix":1},"s":{"a":0,"k":[100,100,100],"ix":6}},"ao":0,"ip":7,"op":8,"st":7,"bm":0},{"ddd":0,"ind":9,"ty":2,"nm":"fr_8.jpg","cl":"jpg","refId":"fr_8","sr":1,"ks":{"o":{"a":0,"k":100,"ix":11},"r":{"a":0,"k":0,"ix":10},"p":{"a":0,"k":[432,432,0],"ix":2},"a":{"a":0,"k":[432,432,0],"ix":1},"s":{"a":0,"k":[100,100,100],"ix":6}},"ao":0,"ip":8,"op":9,"st":8,"bm":0},{"ddd":0,"ind":10,"ty":2,"nm":"fr_9.jpg","cl":"jpg","refId":"fr_9","sr":1,"ks":{"o":{"a":0,"k":100,"ix":11},"r":{"a":0,"k":0,"ix":10},"p":{"a":0,"k":[432,432,0],"ix":2},"a":{"a":0,"k":[432,432,0],"ix":1},"s":{"a":0,"k":[100,100,100],"ix":6}},"ao":0,"ip":9,"op":10,"st":9,"bm":0},{"ddd":0,"ind":11,"ty":2,"nm":"fr_10.jpg","cl":"jpg","refId":"fr_10","sr":1,"ks":{"o":{"a":0,"k":100,"ix":11},"r":{"a":0,"k":0,"ix":10},"p":{"a":0,"k":[432,432,0],"ix":2},"a":{"a":0,"k":[432,432,0],"ix":1},"s":{"a":0,"k":[100,100,100],"ix":6}},"ao":0,"ip":10,"op":11,"st":10,"bm":0},{"ddd":0,"ind":12,"ty":2,"nm":"fr_11.jpg","cl":"jpg","refId":"fr_11","sr":1,"ks":{"o":{"a":0,"k":100,"ix":11},"r":{"a":0,"k":0,"ix":10},"p":{"a":0,"k":[432,432,0],"ix":2},"a":{"a":0,"k":[432,432,0],"ix":1},"s":{"a":0,"k":[100,100,100],"ix":6}},"ao":0,"ip":11,"op":12,"st":11,"bm":0}],"markers":[]} \ No newline at end of file diff --git a/app/src/main/res/raw/done_anim_2.json b/app/src/main/res/raw/done_anim_2.json new file mode 100644 index 0000000..b2d5208 --- /dev/null +++ b/app/src/main/res/raw/done_anim_2.json @@ -0,0 +1 @@ +{"v":"5.5.7","meta":{"g":"LottieFiles AE 0.1.20","a":"","k":"","d":"","tc":""},"fr":29.9700012207031,"ip":0,"op":91.000003706506,"w":1080,"h":1080,"nm":"CHECK","ddd":0,"assets":[{"id":"comp_0","layers":[{"ddd":0,"ind":1,"ty":4,"nm":"Shape Layer 8","sr":1,"ks":{"o":{"a":0,"k":100,"ix":11},"r":{"a":0,"k":315,"ix":10},"p":{"a":0,"k":[552,540,0],"ix":2},"a":{"a":0,"k":[-396,-26.286,0],"ix":1},"s":{"a":0,"k":[70,70,100],"ix":6}},"ao":0,"shapes":[{"ty":"gr","it":[{"ind":0,"ty":"sh","ix":1,"ks":{"a":0,"k":{"i":[[0,0],[0,0]],"o":[[0,0],[0,0]],"v":[[-236,-32],[94.286,-32]],"c":false},"ix":2},"nm":"Path 1","mn":"ADBE Vector Shape - Group","hd":false},{"ty":"tm","s":{"a":1,"k":[{"i":{"x":[0.432],"y":[1]},"o":{"x":[0.622],"y":[0]},"t":4.2,"s":[0]},{"t":14.0000005702317,"s":[100]}],"ix":1},"e":{"a":1,"k":[{"i":{"x":[0.442],"y":[1]},"o":{"x":[0.609],"y":[0]},"t":0,"s":[0]},{"t":10.2675004182038,"s":[100]}],"ix":2},"o":{"a":0,"k":0,"ix":3},"m":1,"ix":2,"nm":"Trim Paths 1","mn":"ADBE Vector Filter - Trim","hd":false},{"ty":"st","c":{"a":0,"k":[0.133333333333,0.800000059838,0.533333333333,1],"ix":3},"o":{"a":0,"k":100,"ix":4},"w":{"a":0,"k":65,"ix":5},"lc":2,"lj":2,"bm":0,"nm":"Stroke 1","mn":"ADBE Vector Graphic - Stroke","hd":false},{"ty":"tr","p":{"a":0,"k":[0,0],"ix":2},"a":{"a":0,"k":[0,0],"ix":1},"s":{"a":0,"k":[100,100],"ix":3},"r":{"a":0,"k":0,"ix":6},"o":{"a":0,"k":100,"ix":7},"sk":{"a":0,"k":0,"ix":4},"sa":{"a":0,"k":0,"ix":5},"nm":"Transform"}],"nm":"Shape 1","np":4,"cix":2,"bm":0,"ix":1,"mn":"ADBE Vector Group","hd":false}],"ip":0,"op":94.0000038286985,"st":0,"bm":0},{"ddd":0,"ind":2,"ty":4,"nm":"Shape Layer 7","sr":1,"ks":{"o":{"a":0,"k":100,"ix":11},"r":{"a":0,"k":270,"ix":10},"p":{"a":0,"k":[552,540,0],"ix":2},"a":{"a":0,"k":[-396,-26.286,0],"ix":1},"s":{"a":0,"k":[70,70,100],"ix":6}},"ao":0,"shapes":[{"ty":"gr","it":[{"ind":0,"ty":"sh","ix":1,"ks":{"a":0,"k":{"i":[[0,0],[0,0]],"o":[[0,0],[0,0]],"v":[[-236,-32],[94.286,-32]],"c":false},"ix":2},"nm":"Path 1","mn":"ADBE Vector Shape - Group","hd":false},{"ty":"tm","s":{"a":1,"k":[{"i":{"x":[0.432],"y":[1]},"o":{"x":[0.622],"y":[0]},"t":4.2,"s":[0]},{"t":14.0000005702317,"s":[100]}],"ix":1},"e":{"a":1,"k":[{"i":{"x":[0.442],"y":[1]},"o":{"x":[0.609],"y":[0]},"t":0,"s":[0]},{"t":10.2675004182038,"s":[100]}],"ix":2},"o":{"a":0,"k":0,"ix":3},"m":1,"ix":2,"nm":"Trim Paths 1","mn":"ADBE Vector Filter - Trim","hd":false},{"ty":"st","c":{"a":0,"k":[0.133333333333,0.800000059838,0.533333333333,1],"ix":3},"o":{"a":0,"k":100,"ix":4},"w":{"a":0,"k":65,"ix":5},"lc":2,"lj":2,"bm":0,"nm":"Stroke 1","mn":"ADBE Vector Graphic - Stroke","hd":false},{"ty":"tr","p":{"a":0,"k":[0,0],"ix":2},"a":{"a":0,"k":[0,0],"ix":1},"s":{"a":0,"k":[100,100],"ix":3},"r":{"a":0,"k":0,"ix":6},"o":{"a":0,"k":100,"ix":7},"sk":{"a":0,"k":0,"ix":4},"sa":{"a":0,"k":0,"ix":5},"nm":"Transform"}],"nm":"Shape 1","np":4,"cix":2,"bm":0,"ix":1,"mn":"ADBE Vector Group","hd":false}],"ip":0,"op":94.0000038286985,"st":0,"bm":0},{"ddd":0,"ind":3,"ty":4,"nm":"Shape Layer 6","sr":1,"ks":{"o":{"a":0,"k":100,"ix":11},"r":{"a":0,"k":225,"ix":10},"p":{"a":0,"k":[552,540,0],"ix":2},"a":{"a":0,"k":[-396,-26.286,0],"ix":1},"s":{"a":0,"k":[70,70,100],"ix":6}},"ao":0,"shapes":[{"ty":"gr","it":[{"ind":0,"ty":"sh","ix":1,"ks":{"a":0,"k":{"i":[[0,0],[0,0]],"o":[[0,0],[0,0]],"v":[[-236,-32],[94.286,-32]],"c":false},"ix":2},"nm":"Path 1","mn":"ADBE Vector Shape - Group","hd":false},{"ty":"tm","s":{"a":1,"k":[{"i":{"x":[0.432],"y":[1]},"o":{"x":[0.622],"y":[0]},"t":4.2,"s":[0]},{"t":14.0000005702317,"s":[100]}],"ix":1},"e":{"a":1,"k":[{"i":{"x":[0.442],"y":[1]},"o":{"x":[0.609],"y":[0]},"t":0,"s":[0]},{"t":10.2675004182038,"s":[100]}],"ix":2},"o":{"a":0,"k":0,"ix":3},"m":1,"ix":2,"nm":"Trim Paths 1","mn":"ADBE Vector Filter - Trim","hd":false},{"ty":"st","c":{"a":0,"k":[0.133333333333,0.800000059838,0.533333333333,1],"ix":3},"o":{"a":0,"k":100,"ix":4},"w":{"a":0,"k":65,"ix":5},"lc":2,"lj":2,"bm":0,"nm":"Stroke 1","mn":"ADBE Vector Graphic - Stroke","hd":false},{"ty":"tr","p":{"a":0,"k":[0,0],"ix":2},"a":{"a":0,"k":[0,0],"ix":1},"s":{"a":0,"k":[100,100],"ix":3},"r":{"a":0,"k":0,"ix":6},"o":{"a":0,"k":100,"ix":7},"sk":{"a":0,"k":0,"ix":4},"sa":{"a":0,"k":0,"ix":5},"nm":"Transform"}],"nm":"Shape 1","np":4,"cix":2,"bm":0,"ix":1,"mn":"ADBE Vector Group","hd":false}],"ip":0,"op":94.0000038286985,"st":0,"bm":0},{"ddd":0,"ind":4,"ty":4,"nm":"Shape Layer 5","sr":1,"ks":{"o":{"a":0,"k":100,"ix":11},"r":{"a":0,"k":180,"ix":10},"p":{"a":0,"k":[552,540,0],"ix":2},"a":{"a":0,"k":[-396,-26.286,0],"ix":1},"s":{"a":0,"k":[70,70,100],"ix":6}},"ao":0,"shapes":[{"ty":"gr","it":[{"ind":0,"ty":"sh","ix":1,"ks":{"a":0,"k":{"i":[[0,0],[0,0]],"o":[[0,0],[0,0]],"v":[[-236,-32],[94.286,-32]],"c":false},"ix":2},"nm":"Path 1","mn":"ADBE Vector Shape - Group","hd":false},{"ty":"tm","s":{"a":1,"k":[{"i":{"x":[0.432],"y":[1]},"o":{"x":[0.622],"y":[0]},"t":4.2,"s":[0]},{"t":14.0000005702317,"s":[100]}],"ix":1},"e":{"a":1,"k":[{"i":{"x":[0.442],"y":[1]},"o":{"x":[0.609],"y":[0]},"t":0,"s":[0]},{"t":10.2675004182038,"s":[100]}],"ix":2},"o":{"a":0,"k":0,"ix":3},"m":1,"ix":2,"nm":"Trim Paths 1","mn":"ADBE Vector Filter - Trim","hd":false},{"ty":"st","c":{"a":0,"k":[0.133333333333,0.800000059838,0.533333333333,1],"ix":3},"o":{"a":0,"k":100,"ix":4},"w":{"a":0,"k":65,"ix":5},"lc":2,"lj":2,"bm":0,"nm":"Stroke 1","mn":"ADBE Vector Graphic - Stroke","hd":false},{"ty":"tr","p":{"a":0,"k":[0,0],"ix":2},"a":{"a":0,"k":[0,0],"ix":1},"s":{"a":0,"k":[100,100],"ix":3},"r":{"a":0,"k":0,"ix":6},"o":{"a":0,"k":100,"ix":7},"sk":{"a":0,"k":0,"ix":4},"sa":{"a":0,"k":0,"ix":5},"nm":"Transform"}],"nm":"Shape 1","np":4,"cix":2,"bm":0,"ix":1,"mn":"ADBE Vector Group","hd":false}],"ip":0,"op":94.0000038286985,"st":0,"bm":0},{"ddd":0,"ind":5,"ty":4,"nm":"Shape Layer 4","sr":1,"ks":{"o":{"a":0,"k":100,"ix":11},"r":{"a":0,"k":135,"ix":10},"p":{"a":0,"k":[552,540,0],"ix":2},"a":{"a":0,"k":[-396,-26.286,0],"ix":1},"s":{"a":0,"k":[70,70,100],"ix":6}},"ao":0,"shapes":[{"ty":"gr","it":[{"ind":0,"ty":"sh","ix":1,"ks":{"a":0,"k":{"i":[[0,0],[0,0]],"o":[[0,0],[0,0]],"v":[[-236,-32],[94.286,-32]],"c":false},"ix":2},"nm":"Path 1","mn":"ADBE Vector Shape - Group","hd":false},{"ty":"tm","s":{"a":1,"k":[{"i":{"x":[0.432],"y":[1]},"o":{"x":[0.622],"y":[0]},"t":4.2,"s":[0]},{"t":14.0000005702317,"s":[100]}],"ix":1},"e":{"a":1,"k":[{"i":{"x":[0.442],"y":[1]},"o":{"x":[0.609],"y":[0]},"t":0,"s":[0]},{"t":10.2675004182038,"s":[100]}],"ix":2},"o":{"a":0,"k":0,"ix":3},"m":1,"ix":2,"nm":"Trim Paths 1","mn":"ADBE Vector Filter - Trim","hd":false},{"ty":"st","c":{"a":0,"k":[0.133333333333,0.800000059838,0.533333333333,1],"ix":3},"o":{"a":0,"k":100,"ix":4},"w":{"a":0,"k":65,"ix":5},"lc":2,"lj":2,"bm":0,"nm":"Stroke 1","mn":"ADBE Vector Graphic - Stroke","hd":false},{"ty":"tr","p":{"a":0,"k":[0,0],"ix":2},"a":{"a":0,"k":[0,0],"ix":1},"s":{"a":0,"k":[100,100],"ix":3},"r":{"a":0,"k":0,"ix":6},"o":{"a":0,"k":100,"ix":7},"sk":{"a":0,"k":0,"ix":4},"sa":{"a":0,"k":0,"ix":5},"nm":"Transform"}],"nm":"Shape 1","np":4,"cix":2,"bm":0,"ix":1,"mn":"ADBE Vector Group","hd":false}],"ip":0,"op":94.0000038286985,"st":0,"bm":0},{"ddd":0,"ind":6,"ty":4,"nm":"Shape Layer 3","sr":1,"ks":{"o":{"a":0,"k":100,"ix":11},"r":{"a":0,"k":90,"ix":10},"p":{"a":0,"k":[552,540,0],"ix":2},"a":{"a":0,"k":[-396,-26.286,0],"ix":1},"s":{"a":0,"k":[70,70,100],"ix":6}},"ao":0,"shapes":[{"ty":"gr","it":[{"ind":0,"ty":"sh","ix":1,"ks":{"a":0,"k":{"i":[[0,0],[0,0]],"o":[[0,0],[0,0]],"v":[[-236,-32],[94.286,-32]],"c":false},"ix":2},"nm":"Path 1","mn":"ADBE Vector Shape - Group","hd":false},{"ty":"tm","s":{"a":1,"k":[{"i":{"x":[0.432],"y":[1]},"o":{"x":[0.622],"y":[0]},"t":4.2,"s":[0]},{"t":14.0000005702317,"s":[100]}],"ix":1},"e":{"a":1,"k":[{"i":{"x":[0.442],"y":[1]},"o":{"x":[0.609],"y":[0]},"t":0,"s":[0]},{"t":10.2675004182038,"s":[100]}],"ix":2},"o":{"a":0,"k":0,"ix":3},"m":1,"ix":2,"nm":"Trim Paths 1","mn":"ADBE Vector Filter - Trim","hd":false},{"ty":"st","c":{"a":0,"k":[0.133333333333,0.800000059838,0.533333333333,1],"ix":3},"o":{"a":0,"k":100,"ix":4},"w":{"a":0,"k":65,"ix":5},"lc":2,"lj":2,"bm":0,"nm":"Stroke 1","mn":"ADBE Vector Graphic - Stroke","hd":false},{"ty":"tr","p":{"a":0,"k":[0,0],"ix":2},"a":{"a":0,"k":[0,0],"ix":1},"s":{"a":0,"k":[100,100],"ix":3},"r":{"a":0,"k":0,"ix":6},"o":{"a":0,"k":100,"ix":7},"sk":{"a":0,"k":0,"ix":4},"sa":{"a":0,"k":0,"ix":5},"nm":"Transform"}],"nm":"Shape 1","np":4,"cix":2,"bm":0,"ix":1,"mn":"ADBE Vector Group","hd":false}],"ip":0,"op":94.0000038286985,"st":0,"bm":0},{"ddd":0,"ind":7,"ty":4,"nm":"Shape Layer 2","sr":1,"ks":{"o":{"a":0,"k":100,"ix":11},"r":{"a":0,"k":45,"ix":10},"p":{"a":0,"k":[552,540,0],"ix":2},"a":{"a":0,"k":[-396,-26.286,0],"ix":1},"s":{"a":0,"k":[70,70,100],"ix":6}},"ao":0,"shapes":[{"ty":"gr","it":[{"ind":0,"ty":"sh","ix":1,"ks":{"a":0,"k":{"i":[[0,0],[0,0]],"o":[[0,0],[0,0]],"v":[[-236,-32],[94.286,-32]],"c":false},"ix":2},"nm":"Path 1","mn":"ADBE Vector Shape - Group","hd":false},{"ty":"tm","s":{"a":1,"k":[{"i":{"x":[0.432],"y":[1]},"o":{"x":[0.622],"y":[0]},"t":4.2,"s":[0]},{"t":14.0000005702317,"s":[100]}],"ix":1},"e":{"a":1,"k":[{"i":{"x":[0.442],"y":[1]},"o":{"x":[0.609],"y":[0]},"t":0,"s":[0]},{"t":10.2675004182038,"s":[100]}],"ix":2},"o":{"a":0,"k":0,"ix":3},"m":1,"ix":2,"nm":"Trim Paths 1","mn":"ADBE Vector Filter - Trim","hd":false},{"ty":"st","c":{"a":0,"k":[0.133333333333,0.800000059838,0.533333333333,1],"ix":3},"o":{"a":0,"k":100,"ix":4},"w":{"a":0,"k":65,"ix":5},"lc":2,"lj":2,"bm":0,"nm":"Stroke 1","mn":"ADBE Vector Graphic - Stroke","hd":false},{"ty":"tr","p":{"a":0,"k":[0,0],"ix":2},"a":{"a":0,"k":[0,0],"ix":1},"s":{"a":0,"k":[100,100],"ix":3},"r":{"a":0,"k":0,"ix":6},"o":{"a":0,"k":100,"ix":7},"sk":{"a":0,"k":0,"ix":4},"sa":{"a":0,"k":0,"ix":5},"nm":"Transform"}],"nm":"Shape 1","np":4,"cix":2,"bm":0,"ix":1,"mn":"ADBE Vector Group","hd":false}],"ip":0,"op":94.0000038286985,"st":0,"bm":0},{"ddd":0,"ind":8,"ty":4,"nm":"Shape Layer 1","sr":1,"ks":{"o":{"a":0,"k":100,"ix":11},"r":{"a":0,"k":0,"ix":10},"p":{"a":0,"k":[552,540,0],"ix":2},"a":{"a":0,"k":[-396,-26.286,0],"ix":1},"s":{"a":0,"k":[70,70,100],"ix":6}},"ao":0,"shapes":[{"ty":"gr","it":[{"ind":0,"ty":"sh","ix":1,"ks":{"a":0,"k":{"i":[[0,0],[0,0]],"o":[[0,0],[0,0]],"v":[[-236,-32],[94.286,-32]],"c":false},"ix":2},"nm":"Path 1","mn":"ADBE Vector Shape - Group","hd":false},{"ty":"tm","s":{"a":1,"k":[{"i":{"x":[0.432],"y":[1]},"o":{"x":[0.622],"y":[0]},"t":4.2,"s":[0]},{"t":14.0000005702317,"s":[100]}],"ix":1},"e":{"a":1,"k":[{"i":{"x":[0.442],"y":[1]},"o":{"x":[0.609],"y":[0]},"t":0,"s":[0]},{"t":10.2675004182038,"s":[100]}],"ix":2},"o":{"a":0,"k":0,"ix":3},"m":1,"ix":2,"nm":"Trim Paths 1","mn":"ADBE Vector Filter - Trim","hd":false},{"ty":"st","c":{"a":0,"k":[0.133333333333,0.800000059838,0.533333333333,1],"ix":3},"o":{"a":0,"k":100,"ix":4},"w":{"a":0,"k":65,"ix":5},"lc":2,"lj":2,"bm":0,"nm":"Stroke 1","mn":"ADBE Vector Graphic - Stroke","hd":false},{"ty":"tr","p":{"a":0,"k":[0,0],"ix":2},"a":{"a":0,"k":[0,0],"ix":1},"s":{"a":0,"k":[100,100],"ix":3},"r":{"a":0,"k":0,"ix":6},"o":{"a":0,"k":100,"ix":7},"sk":{"a":0,"k":0,"ix":4},"sa":{"a":0,"k":0,"ix":5},"nm":"Transform"}],"nm":"Shape 1","np":4,"cix":2,"bm":0,"ix":1,"mn":"ADBE Vector Group","hd":false}],"ip":0,"op":94.0000038286985,"st":0,"bm":0}]}],"layers":[{"ddd":0,"ind":1,"ty":0,"nm":"Comp 2","refId":"comp_0","sr":1,"ks":{"o":{"a":0,"k":100,"ix":11},"r":{"a":0,"k":0,"ix":10},"p":{"a":0,"k":[496,220,0],"ix":2},"a":{"a":0,"k":[540,540,0],"ix":1},"s":{"a":0,"k":[31.111,31.111,100],"ix":6}},"ao":0,"w":1080,"h":1080,"ip":14.0000005702317,"op":108.00000439893,"st":14.0000005702317,"bm":0},{"ddd":0,"ind":2,"ty":4,"nm":"Shape Layer 2","sr":1,"ks":{"o":{"a":0,"k":100,"ix":11},"r":{"a":0,"k":0,"ix":10},"p":{"a":0,"k":[524,552,0],"ix":2},"a":{"a":0,"k":[0,0,0],"ix":1},"s":{"a":0,"k":[100,100,100],"ix":6}},"ao":0,"shapes":[{"ty":"gr","it":[{"ind":0,"ty":"sh","ix":1,"ks":{"a":0,"k":{"i":[[0,0],[0,0],[0,0]],"o":[[0,0],[0,0],[0,0]],"v":[[-156,36],[-32,160],[220,-140]],"c":false},"ix":2},"nm":"Path 1","mn":"ADBE Vector Shape - Group","hd":false},{"ty":"st","c":{"a":0,"k":[1,1,1,1],"ix":3},"o":{"a":0,"k":100,"ix":4},"w":{"a":0,"k":59,"ix":5},"lc":2,"lj":2,"bm":0,"nm":"Stroke 1","mn":"ADBE Vector Graphic - Stroke","hd":false},{"ty":"tr","p":{"a":0,"k":[0,0],"ix":2},"a":{"a":0,"k":[0,0],"ix":1},"s":{"a":0,"k":[100,100],"ix":3},"r":{"a":0,"k":0,"ix":6},"o":{"a":0,"k":100,"ix":7},"sk":{"a":0,"k":0,"ix":4},"sa":{"a":0,"k":0,"ix":5},"nm":"Transform"}],"nm":"Shape 1","np":3,"cix":2,"bm":0,"ix":1,"mn":"ADBE Vector Group","hd":false},{"ty":"tm","s":{"a":0,"k":0,"ix":1},"e":{"a":1,"k":[{"i":{"x":[0.221],"y":[1]},"o":{"x":[0.333],"y":[0]},"t":28,"s":[0]},{"i":{"x":[0.191],"y":[1]},"o":{"x":[0.333],"y":[0]},"t":44,"s":[100]},{"t":59.0000024031193,"s":[87]}],"ix":2},"o":{"a":0,"k":0,"ix":3},"m":1,"ix":2,"nm":"Trim Paths 1","mn":"ADBE Vector Filter - Trim","hd":false}],"ip":28.0000011404634,"op":122.000004969162,"st":28.0000011404634,"bm":0},{"ddd":0,"ind":3,"ty":4,"nm":"Shape Layer 1","sr":1,"ks":{"o":{"a":0,"k":100,"ix":11},"r":{"a":0,"k":0,"ix":10},"p":{"a":0,"k":[540,540,0],"ix":2},"a":{"a":0,"k":[0,0,0],"ix":1},"s":{"a":0,"k":[60,60,100],"ix":6}},"ao":0,"shapes":[{"ty":"gr","it":[{"d":1,"ty":"el","s":{"a":0,"k":[1080,1080],"ix":2},"p":{"a":0,"k":[0,0],"ix":3},"nm":"Ellipse Path 1","mn":"ADBE Vector Shape - Ellipse","hd":false},{"ty":"st","c":{"a":0,"k":[0.133333333333,0.800000059838,0.533333333333,1],"ix":3},"o":{"a":0,"k":100,"ix":4},"w":{"a":0,"k":65,"ix":5},"lc":2,"lj":2,"bm":0,"nm":"Stroke 1","mn":"ADBE Vector Graphic - Stroke","hd":false},{"ty":"tr","p":{"a":0,"k":[0,0],"ix":2},"a":{"a":0,"k":[0,0],"ix":1},"s":{"a":0,"k":[100,100],"ix":3},"r":{"a":0,"k":0,"ix":6},"o":{"a":0,"k":100,"ix":7},"sk":{"a":0,"k":0,"ix":4},"sa":{"a":0,"k":0,"ix":5},"nm":"Transform"}],"nm":"Ellipse 1","np":3,"cix":2,"bm":0,"ix":1,"mn":"ADBE Vector Group","hd":false},{"ty":"tm","s":{"a":0,"k":0,"ix":1},"e":{"a":1,"k":[{"i":{"x":[0.113],"y":[1]},"o":{"x":[0.647],"y":[0]},"t":0,"s":[0]},{"t":22.0000008960784,"s":[100]}],"ix":2},"o":{"a":0,"k":0,"ix":3},"m":1,"ix":2,"nm":"Trim Paths 1","mn":"ADBE Vector Filter - Trim","hd":false}],"ip":0,"op":94.0000038286985,"st":0,"bm":0},{"ddd":0,"ind":4,"ty":4,"nm":"Shape Layer 5","sr":1,"ks":{"o":{"a":0,"k":100,"ix":11},"r":{"a":0,"k":0,"ix":10},"p":{"a":0,"k":[540,540,0],"ix":2},"a":{"a":0,"k":[0,0,0],"ix":1},"s":{"a":1,"k":[{"i":{"x":[0.321,0.321,0.667],"y":[1,1,1]},"o":{"x":[0.725,0.725,0.333],"y":[0,0,0]},"t":17,"s":[0,0,100]},{"t":40.0000016292334,"s":[60,60,100]}],"ix":6}},"ao":0,"shapes":[{"ty":"gr","it":[{"d":1,"ty":"el","s":{"a":0,"k":[1080,1080],"ix":2},"p":{"a":0,"k":[0,0],"ix":3},"nm":"Ellipse Path 1","mn":"ADBE Vector Shape - Ellipse","hd":false},{"ty":"st","c":{"a":0,"k":[0.956862984452,0.145097994337,0.203922002456,1],"ix":3},"o":{"a":0,"k":100,"ix":4},"w":{"a":0,"k":0,"ix":5},"lc":1,"lj":1,"ml":4,"bm":0,"nm":"Stroke 1","mn":"ADBE Vector Graphic - Stroke","hd":false},{"ty":"fl","c":{"a":0,"k":[0.131938231225,0.799417892157,0.534389181698,1],"ix":4},"o":{"a":0,"k":100,"ix":5},"r":1,"bm":0,"nm":"Fill 1","mn":"ADBE Vector Graphic - Fill","hd":false},{"ty":"tr","p":{"a":0,"k":[0,0],"ix":2},"a":{"a":0,"k":[0,0],"ix":1},"s":{"a":0,"k":[100,100],"ix":3},"r":{"a":0,"k":0,"ix":6},"o":{"a":0,"k":100,"ix":7},"sk":{"a":0,"k":0,"ix":4},"sa":{"a":0,"k":0,"ix":5},"nm":"Transform"}],"nm":"Ellipse 1","np":3,"cix":2,"bm":0,"ix":1,"mn":"ADBE Vector Group","hd":false}],"ip":17.0000006924242,"op":111.000004521123,"st":17.0000006924242,"bm":0}],"markers":[]} \ No newline at end of file diff --git a/app/src/main/res/values-night/themes.xml b/app/src/main/res/values-night/themes.xml new file mode 100644 index 0000000..81094f8 --- /dev/null +++ b/app/src/main/res/values-night/themes.xml @@ -0,0 +1,25 @@ + + + + + // top corner rounded bottom sheet + + + + \ No newline at end of file diff --git a/app/src/main/res/values/colors.xml b/app/src/main/res/values/colors.xml new file mode 100644 index 0000000..da75ae0 --- /dev/null +++ b/app/src/main/res/values/colors.xml @@ -0,0 +1,15 @@ + + + #FFBB86FC + #FF6200EE + #FF3700B3 + #FF03DAC5 + #FF018786 + #FF000000 + #FFFFFFFF + #FFFFFF + + #1B6DC1 + #C9E0FB + + \ No newline at end of file diff --git a/app/src/main/res/values/strings.xml b/app/src/main/res/values/strings.xml new file mode 100644 index 0000000..b7c9969 --- /dev/null +++ b/app/src/main/res/values/strings.xml @@ -0,0 +1,123 @@ + + SimpliTend + Welcome to\nSimpliTend + Caring for a loved one may be\noverwhelming.... Let our app\nassist you! + logo_bg + welcome_illustration + next_btn + Choose a role + First, install the app on the senior\'s phone. The app will then send an invitation to the caregiver, along with the security code needed to set up the app on his or her phone. + background + Senior + You are seeking assistance and care. + Caregiver + You are caring for your loved one. + onboard_image + Avoid unwanted phone calls! + Continue using your Smartphone without the annoying robocalls and spam text messages. + Have a worry\nfree stroll!! + Get direction to home with a push a button from your smartphone home screen + Never miss a med or forget a refill again + Configure medication reminders and alerts. Include the dosage, instructions, and refill date. + Register + Login + Welcome to SimpliTend + Sign in to continue. + Email address + Enter your email. + Enter pin + Enter your pin + Remember me + Forgot pin ? + back_button + Forgot Pin? + Don\'t worry! it happens. Please enter the address associated with your account + Enter email address + Submit + Check your mail + Please enter the temporary pin recieved at email address at ******k@gmail.com + Didn\'t your receive any code? + Resend + Change your Pin + For your security, Please change the temporary pin to a new pin + New Pin + Enter your new pin + Confirm your Pin + Reset Pin + Lets get started + Enter your contact information + Name* + Enter your full name + Date of birth* + Enter your date of birth + Contact number* + Phone number + (optional) + I accept terms and conditions + Next + Choose on map + Drag the map and choose the place + Map view + Home address + Enter your street + Enter your town + Enter your state + Enter your country + Enter your zip code + Create a pin + Create a pin to securely store your personal data + Set 4 digit login pin + Set pin + Thank you ! + Let\'s add your caregiver contact information + Proceed + Please add your caregiver contact information + Search contact + Create new contact + Create contact + Edit contact + Save + Change photo + Add photo + Relationship* + Make current contact as a caregiver + Make current contact as In Case Of Emergency Contact (SOS) + *SOS is set to E911 default + Enter your relationship + + Are you sure you want to change the contact to SOS ? + Are you sure you want to save the changes ? + Yes + No + + Changes successful + Add 10 family and friend contact information + *Atleast add one contact + Contact information + static_12345@gmail.com + 12-02-2001 + Caregiver ( Emergency contact ) + +918208401763 + How to setup? + 1 + Create an account + Enter your contact information and set up a pin. + 2 + Select caregiver + App will send an invitation to your caregiver. + 3 + Caregiver setup + Ask your caregiver to download the app on his/her phone and create an account. + 4 + Are you Ready! + Take your time and finish your profile, add contacts, reminders and so on. + Lets complete\nthe rest of your profile + Personal information + Family and friends contacts + Medication Reminder + Medical information + Setup routine + Frequently used apps + Skip to dashboard + * + \ No newline at end of file diff --git a/app/src/main/res/values/themes.xml b/app/src/main/res/values/themes.xml new file mode 100644 index 0000000..29a9d20 --- /dev/null +++ b/app/src/main/res/values/themes.xml @@ -0,0 +1,25 @@ + + + + + // top corner rounded bottom sheet + + + + \ No newline at end of file diff --git a/app/src/main/res/xml/backup_rules.xml b/app/src/main/res/xml/backup_rules.xml new file mode 100644 index 0000000..fa0f996 --- /dev/null +++ b/app/src/main/res/xml/backup_rules.xml @@ -0,0 +1,13 @@ + + + + \ No newline at end of file diff --git a/app/src/main/res/xml/data_extraction_rules.xml b/app/src/main/res/xml/data_extraction_rules.xml new file mode 100644 index 0000000..9ee9997 --- /dev/null +++ b/app/src/main/res/xml/data_extraction_rules.xml @@ -0,0 +1,19 @@ + + + + + + + \ No newline at end of file diff --git a/app/src/test/java/com/ssb/simplitend/ExampleUnitTest.java b/app/src/test/java/com/ssb/simplitend/ExampleUnitTest.java new file mode 100644 index 0000000..276ba2b --- /dev/null +++ b/app/src/test/java/com/ssb/simplitend/ExampleUnitTest.java @@ -0,0 +1,17 @@ +package com.ssb.simplitend; + +import org.junit.Test; + +import static org.junit.Assert.*; + +/** + * Example local unit test, which will execute on the development machine (host). + * + * @see Testing documentation + */ +public class ExampleUnitTest { + @Test + public void addition_isCorrect() { + assertEquals(4, 2 + 2); + } +} \ No newline at end of file diff --git a/build.gradle b/build.gradle new file mode 100644 index 0000000..71b99f4 --- /dev/null +++ b/build.gradle @@ -0,0 +1,5 @@ +// Top-level build file where you can add configuration options common to all sub-projects/modules. +plugins { + id 'com.android.application' version '7.3.1' apply false + id 'com.android.library' version '7.3.1' apply false +} \ No newline at end of file diff --git a/gradle.properties b/gradle.properties new file mode 100644 index 0000000..3e927b1 --- /dev/null +++ b/gradle.properties @@ -0,0 +1,21 @@ +# Project-wide Gradle settings. +# IDE (e.g. Android Studio) users: +# Gradle settings configured through the IDE *will override* +# any settings specified in this file. +# For more details on how to configure your build environment visit +# http://www.gradle.org/docs/current/userguide/build_environment.html +# Specifies the JVM arguments used for the daemon process. +# The setting is particularly useful for tweaking memory settings. +org.gradle.jvmargs=-Xmx2048m -Dfile.encoding=UTF-8 +# When configured, Gradle will run in incubating parallel mode. +# This option should only be used with decoupled projects. More details, visit +# http://www.gradle.org/docs/current/userguide/multi_project_builds.html#sec:decoupled_projects +# org.gradle.parallel=true +# AndroidX package structure to make it clearer which packages are bundled with the +# Android operating system, and which are packaged with your app's APK +# https://developer.android.com/topic/libraries/support-library/androidx-rn +android.useAndroidX=true +# Enables namespacing of each library's R class so that its R class includes only the +# resources declared in the library itself and none from the library's dependencies, +# thereby reducing the size of the R class for that library +android.nonTransitiveRClass=true \ No newline at end of file diff --git a/gradle/wrapper/gradle-wrapper.jar b/gradle/wrapper/gradle-wrapper.jar new file mode 100644 index 0000000..e708b1c Binary files /dev/null and b/gradle/wrapper/gradle-wrapper.jar differ diff --git a/gradle/wrapper/gradle-wrapper.properties b/gradle/wrapper/gradle-wrapper.properties new file mode 100644 index 0000000..61c61e1 --- /dev/null +++ b/gradle/wrapper/gradle-wrapper.properties @@ -0,0 +1,6 @@ +#Mon Jun 26 13:52:22 IST 2023 +distributionBase=GRADLE_USER_HOME +distributionUrl=https\://services.gradle.org/distributions/gradle-7.4-bin.zip +distributionPath=wrapper/dists +zipStorePath=wrapper/dists +zipStoreBase=GRADLE_USER_HOME diff --git a/gradlew b/gradlew new file mode 100644 index 0000000..4f906e0 --- /dev/null +++ b/gradlew @@ -0,0 +1,185 @@ +#!/usr/bin/env sh + +# +# Copyright 2015 the original author or authors. +# +# Licensed under the Apache License, Version 2.0 (the "License"); +# you may not use this file except in compliance with the License. +# You may obtain a copy of the License at +# +# https://www.apache.org/licenses/LICENSE-2.0 +# +# Unless required by applicable law or agreed to in writing, software +# distributed under the License is distributed on an "AS IS" BASIS, +# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. +# See the License for the specific language governing permissions and +# limitations under the License. +# + +############################################################################## +## +## Gradle start up script for UN*X +## +############################################################################## + +# Attempt to set APP_HOME +# Resolve links: $0 may be a link +PRG="$0" +# Need this for relative symlinks. +while [ -h "$PRG" ] ; do + ls=`ls -ld "$PRG"` + link=`expr "$ls" : '.*-> \(.*\)$'` + if expr "$link" : '/.*' > /dev/null; then + PRG="$link" + else + PRG=`dirname "$PRG"`"/$link" + fi +done +SAVED="`pwd`" +cd "`dirname \"$PRG\"`/" >/dev/null +APP_HOME="`pwd -P`" +cd "$SAVED" >/dev/null + +APP_NAME="Gradle" +APP_BASE_NAME=`basename "$0"` + +# Add default JVM options here. You can also use JAVA_OPTS and GRADLE_OPTS to pass JVM options to this script. +DEFAULT_JVM_OPTS='"-Xmx64m" "-Xms64m"' + +# Use the maximum available, or set MAX_FD != -1 to use that value. +MAX_FD="maximum" + +warn () { + echo "$*" +} + +die () { + echo + echo "$*" + echo + exit 1 +} + +# OS specific support (must be 'true' or 'false'). +cygwin=false +msys=false +darwin=false +nonstop=false +case "`uname`" in + CYGWIN* ) + cygwin=true + ;; + Darwin* ) + darwin=true + ;; + MINGW* ) + msys=true + ;; + NONSTOP* ) + nonstop=true + ;; +esac + +CLASSPATH=$APP_HOME/gradle/wrapper/gradle-wrapper.jar + + +# Determine the Java command to use to start the JVM. +if [ -n "$JAVA_HOME" ] ; then + if [ -x "$JAVA_HOME/jre/sh/java" ] ; then + # IBM's JDK on AIX uses strange locations for the executables + JAVACMD="$JAVA_HOME/jre/sh/java" + else + JAVACMD="$JAVA_HOME/bin/java" + fi + if [ ! -x "$JAVACMD" ] ; then + die "ERROR: JAVA_HOME is set to an invalid directory: $JAVA_HOME + +Please set the JAVA_HOME variable in your environment to match the +location of your Java installation." + fi +else + JAVACMD="java" + which java >/dev/null 2>&1 || die "ERROR: JAVA_HOME is not set and no 'java' command could be found in your PATH. + +Please set the JAVA_HOME variable in your environment to match the +location of your Java installation." +fi + +# Increase the maximum file descriptors if we can. +if [ "$cygwin" = "false" -a "$darwin" = "false" -a "$nonstop" = "false" ] ; then + MAX_FD_LIMIT=`ulimit -H -n` + if [ $? -eq 0 ] ; then + if [ "$MAX_FD" = "maximum" -o "$MAX_FD" = "max" ] ; then + MAX_FD="$MAX_FD_LIMIT" + fi + ulimit -n $MAX_FD + if [ $? -ne 0 ] ; then + warn "Could not set maximum file descriptor limit: $MAX_FD" + fi + else + warn "Could not query maximum file descriptor limit: $MAX_FD_LIMIT" + fi +fi + +# For Darwin, add options to specify how the application appears in the dock +if $darwin; then + GRADLE_OPTS="$GRADLE_OPTS \"-Xdock:name=$APP_NAME\" \"-Xdock:icon=$APP_HOME/media/gradle.icns\"" +fi + +# For Cygwin or MSYS, switch paths to Windows format before running java +if [ "$cygwin" = "true" -o "$msys" = "true" ] ; then + APP_HOME=`cygpath --path --mixed "$APP_HOME"` + CLASSPATH=`cygpath --path --mixed "$CLASSPATH"` + + JAVACMD=`cygpath --unix "$JAVACMD"` + + # We build the pattern for arguments to be converted via cygpath + ROOTDIRSRAW=`find -L / -maxdepth 1 -mindepth 1 -type d 2>/dev/null` + SEP="" + for dir in $ROOTDIRSRAW ; do + ROOTDIRS="$ROOTDIRS$SEP$dir" + SEP="|" + done + OURCYGPATTERN="(^($ROOTDIRS))" + # Add a user-defined pattern to the cygpath arguments + if [ "$GRADLE_CYGPATTERN" != "" ] ; then + OURCYGPATTERN="$OURCYGPATTERN|($GRADLE_CYGPATTERN)" + fi + # Now convert the arguments - kludge to limit ourselves to /bin/sh + i=0 + for arg in "$@" ; do + CHECK=`echo "$arg"|egrep -c "$OURCYGPATTERN" -` + CHECK2=`echo "$arg"|egrep -c "^-"` ### Determine if an option + + if [ $CHECK -ne 0 ] && [ $CHECK2 -eq 0 ] ; then ### Added a condition + eval `echo args$i`=`cygpath --path --ignore --mixed "$arg"` + else + eval `echo args$i`="\"$arg\"" + fi + i=`expr $i + 1` + done + case $i in + 0) set -- ;; + 1) set -- "$args0" ;; + 2) set -- "$args0" "$args1" ;; + 3) set -- "$args0" "$args1" "$args2" ;; + 4) set -- "$args0" "$args1" "$args2" "$args3" ;; + 5) set -- "$args0" "$args1" "$args2" "$args3" "$args4" ;; + 6) set -- "$args0" "$args1" "$args2" "$args3" "$args4" "$args5" ;; + 7) set -- "$args0" "$args1" "$args2" "$args3" "$args4" "$args5" "$args6" ;; + 8) set -- "$args0" "$args1" "$args2" "$args3" "$args4" "$args5" "$args6" "$args7" ;; + 9) set -- "$args0" "$args1" "$args2" "$args3" "$args4" "$args5" "$args6" "$args7" "$args8" ;; + esac +fi + +# Escape application args +save () { + for i do printf %s\\n "$i" | sed "s/'/'\\\\''/g;1s/^/'/;\$s/\$/' \\\\/" ; done + echo " " +} +APP_ARGS=`save "$@"` + +# Collect all arguments for the java command, following the shell quoting and substitution rules +eval set -- $DEFAULT_JVM_OPTS $JAVA_OPTS $GRADLE_OPTS "\"-Dorg.gradle.appname=$APP_BASE_NAME\"" -classpath "\"$CLASSPATH\"" org.gradle.wrapper.GradleWrapperMain "$APP_ARGS" + +exec "$JAVACMD" "$@" diff --git a/gradlew.bat b/gradlew.bat new file mode 100644 index 0000000..107acd3 --- /dev/null +++ b/gradlew.bat @@ -0,0 +1,89 @@ +@rem +@rem Copyright 2015 the original author or authors. +@rem +@rem Licensed under the Apache License, Version 2.0 (the "License"); +@rem you may not use this file except in compliance with the License. +@rem You may obtain a copy of the License at +@rem +@rem https://www.apache.org/licenses/LICENSE-2.0 +@rem +@rem Unless required by applicable law or agreed to in writing, software +@rem distributed under the License is distributed on an "AS IS" BASIS, +@rem WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. +@rem See the License for the specific language governing permissions and +@rem limitations under the License. +@rem + +@if "%DEBUG%" == "" @echo off +@rem ########################################################################## +@rem +@rem Gradle startup script for Windows +@rem +@rem ########################################################################## + +@rem Set local scope for the variables with windows NT shell +if "%OS%"=="Windows_NT" setlocal + +set DIRNAME=%~dp0 +if "%DIRNAME%" == "" set DIRNAME=. +set APP_BASE_NAME=%~n0 +set APP_HOME=%DIRNAME% + +@rem Resolve any "." and ".." in APP_HOME to make it shorter. +for %%i in ("%APP_HOME%") do set APP_HOME=%%~fi + +@rem Add default JVM options here. You can also use JAVA_OPTS and GRADLE_OPTS to pass JVM options to this script. +set DEFAULT_JVM_OPTS="-Xmx64m" "-Xms64m" + +@rem Find java.exe +if defined JAVA_HOME goto findJavaFromJavaHome + +set JAVA_EXE=java.exe +%JAVA_EXE% -version >NUL 2>&1 +if "%ERRORLEVEL%" == "0" goto execute + +echo. +echo ERROR: JAVA_HOME is not set and no 'java' command could be found in your PATH. +echo. +echo Please set the JAVA_HOME variable in your environment to match the +echo location of your Java installation. + +goto fail + +:findJavaFromJavaHome +set JAVA_HOME=%JAVA_HOME:"=% +set JAVA_EXE=%JAVA_HOME%/bin/java.exe + +if exist "%JAVA_EXE%" goto execute + +echo. +echo ERROR: JAVA_HOME is set to an invalid directory: %JAVA_HOME% +echo. +echo Please set the JAVA_HOME variable in your environment to match the +echo location of your Java installation. + +goto fail + +:execute +@rem Setup the command line + +set CLASSPATH=%APP_HOME%\gradle\wrapper\gradle-wrapper.jar + + +@rem Execute Gradle +"%JAVA_EXE%" %DEFAULT_JVM_OPTS% %JAVA_OPTS% %GRADLE_OPTS% "-Dorg.gradle.appname=%APP_BASE_NAME%" -classpath "%CLASSPATH%" org.gradle.wrapper.GradleWrapperMain %* + +:end +@rem End local scope for the variables with windows NT shell +if "%ERRORLEVEL%"=="0" goto mainEnd + +:fail +rem Set variable GRADLE_EXIT_CONSOLE if you need the _script_ return code instead of +rem the _cmd.exe /c_ return code! +if not "" == "%GRADLE_EXIT_CONSOLE%" exit 1 +exit /b 1 + +:mainEnd +if "%OS%"=="Windows_NT" endlocal + +:omega diff --git a/settings.gradle b/settings.gradle new file mode 100644 index 0000000..bc9b461 --- /dev/null +++ b/settings.gradle @@ -0,0 +1,16 @@ +pluginManagement { + repositories { + gradlePluginPortal() + google() + mavenCentral() + } +} +dependencyResolutionManagement { + repositoriesMode.set(RepositoriesMode.FAIL_ON_PROJECT_REPOS) + repositories { + google() + mavenCentral() + } +} +rootProject.name = "SimpliTend" +include ':app'