KO | EN

GitLite

Minimalist Open Source Repository Search Engine

gitlite — search

#dsh #dsh-plugin #ai-agents #developer-tools #typescript #codex #cli #claude-code #mcp #rust #deepseek-harness #ai-agent

SimpleStore

★ 14 Open GitHub ↗

An Android library that helps you handle all the code for shared preference, datastore and blockstore.

// repository documentation

Was this content helpful?

★ 0 (0 ratings)

<div align="center">
<h1>SimpleStore Android Library</h1>

## SimpleStore Android Library
A library to create shared preference, data store and block store. it has the ability to encrypt on a go, by just signifying on the builder class.

### 1. Adding SimpleStore to your project

* Include jitpack in your root `settings.gradle` file.

```gradle
pluginManagement {
    repositories {
        ...
        maven { url 'https://jitpack.io' }
    }
}

dependencyResolutionManagement {
    repositoriesMode.set(RepositoriesMode.FAIL_ON_PROJECT_REPOS)
    repositories {
        ...
        maven { url 'https://jitpack.io' }
    }
}
```

* And add it's dependency to your app level `build.gradle` file:

```gradle
dependencies {
    implementation 'com.github.RhymezxCode:SimpleStore:1.1.1'
}
```

#### Sync your project, and :scream: boom :fire: you have added SimpleStore successfully. :exclamation:

### 2. Usage

##  Using datastore
* First initialize the builder class:

```kt
     val store = SimpleStore.Builder()
        .context(context = this)
        .storeName("AnyName of your choice")
        .encryption(encrypted = false)
        .build()
```

* To save a string:
```kt
       lifecycleScope.launch {
                store.getType<DatastorePreference>().saveStringToStore(
                    "name",
                    "My name"
                )
            }
```

* To save a boolean:
```kt
       lifecycleScope.launch {
                store.getType<DatastorePreference>().saveBooleanToStore(
                    "default",
                    true
                )
            }
```

* Get a string that you saved:
```kt
        lifecycleScope.launchWhenCreated {
binding.sharedPreferenceValue.text = store.getType<DatastorePreference>()
                    .getStringFromStore("name").first()
            }
```

* Get a boolean that you saved:
```kt
       val default = false
       lifecycleScope.launchWhenCreated {
                default = store.getType<DatastorePreference>()
                    .getBooleanFromStore("default").first()
            }
```

##  Using shared preference
* First initialize the builder class:

```kt
     val store = SimpleStore.Builder()
        .context(context = this)
        .storeName("AnyName of your choice")
        .encryption(encrypted = false)
        .build()
```
##  Using encrypted shared preference
* First initialize the builder class:

```kt
     val store = SimpleStore.Builder()
        .context(context = this)
        .storeName("AnyName of your choice")
        .encryption(encrypted = true)
        .build()
```

* To save a string:
```kt
       lifecycleScope.launch {
                store.getType<SharedPreference>().saveStringToStore(
                    "name",
                    "My name"
                )
            }
```

* To save a boolean:
```kt
       lifecycleScope.launch {
                store.getType<SharedPreference>().saveBooleanToStore(
                    "default",
                    true
                )
            }
```

##  Using BlockStore
* First initialize the builder class:

```kt
     val store = SimpleStore.Builder()
        .context(context = this)
        .build()
```
* enable cloud with E2E encryption from the builder class:

```kt
     val store = SimpleStore.Builder()
        .context(context = this)
        .enableCloudForBlockStore(true)
        .build()
```

* To save a byteArray:
```kt
       lifecycleScope.launch {
                store.getType<BlockStore>().saveByteArrayToStore(
                    "name",
                    byteArrayOf(1, 2, 3, 4)
                )
            }
```

* Get the byteArray that you saved:
```kt
        lifecycleScope.launch{
binding.sharedPreferenceValue.text = store.getType<BlockStore>()
                    .getByteArrayFromStore("name")
```

* To clear your BlockStore:
```kt
       lifecycleScope.launch{
        val default = store.getType<BlockStore>()
                    .clearAllTheStore()
                    
                if(default){
                    //your data is cleared
                    }else{
                    //your data is not cleared
                }  
            }
```

* To delete a specific key data from your BlockStore:
```kt     
  lifecycleScope.launch{
        val default = store.getType<BlockStore>()
                    .deleteByKey("key name")

if(default){
                    //your specific key data is deleted
                    }else{
                   //your specific key data is not deleted
                 }  
            }
```
    
### 3. You can also inject SimpleStore, and use it everywhere in your app with Hilt :syringe: :

* Create an object for SimpleStoreModule in your di package:

```kt
@InstallIn(SingletonComponent::class)
@Module
object SimpleStoreModule{

@Provides
    @Singleton
    fun provideStore(
        @ApplicationContext context: Context
    ) = SimpleStore.Builder()
        .context(context = context)
        .storeName("AnyName")
        .encryption(encrypted = false)
        .build()

}
```

* Declare the variable in your class either a fragment or activity, it works in both:

```kt
@RequiresApi(Build.VERSION_CODES.M)
@AndroidEntryPoint
class MainActivity : AppCompatActivity() {
    private lateinit var binding: ActivityMainBinding

@Inject
    lateinit var store: SimpleStore

override fun onCreate(savedInstanceState: Bundle?) {
        super.onCreate(savedInstanceState)
        binding = ActivityMainBinding.inflate(layoutInflater)
        setContentView(binding.root)

binding.store.setOnClickListener {
            lifecycleScope.launch {
                store.getType<DatastorePreference>().saveStringToStore(
                    "name",
                    binding.editTextTextPersonName.text.toString()
                )
            }

lifecycleScope.launchWhenCreated {
binding.sharedPreferenceValue.text =
                store.getType<DatastorePreference>()
                    .getStringFromStore("name").first()
            }
        }
    }

}
 ```
Please note: Encrypted datastore is still in development, I will push a new version when it is ready! <br><br>
:pushpin: Please, feel free to give me a star :star2:, I also love sparkles :sparkles: :relaxed:
<div align="center">
    <sub>Developed with :sparkling_heart: by
        <a href="https://github.com/RhymezxCode">Awodire Babajide Samuel</a>
    </sub>
</div>

SimpleStore

Explore Similar Repositories

Was this content helpful?

Recent Feedback

Download README