I think the problem is the following, you are not checking if Firebase user installs it with a logged user. When vc enters the login screen, do not check if a logged user, then log in again and overwrites the user's instance. Place this code in the oncreate of your login activityFirebaseAuth mAuth = FirebaseAuth.getInstance(); try { Log.i("Entrou","Entrou no diferente de nulo" + " " + mAuth.getCurrentUser().getUid()); startActivity(new Intent(getApplicationContext(),MenuOrdemServico.class)); }catch (NullPointerException n) { // entrou no catch, mAuth == null }

Try this:private String KEY_CODIGO = "KEY_CODIGO"; SharedPreferences.Editor editor_Codigo = oCodigo.edit(); editor_Codigo.putString(KEY_CODIGO , pUsuario.getCodigo()); editor_Codigo.commit(); In search of value:SharedPreferences oCodigo = pContext.getSharedPreferences("file.preferences", Context.MODE_PRIVATE); String codigo = oCodigo.getString(KEY_CODIGO , "")); return Integer.parseInt(codigo); I recommend using SharedPreferences in a class only to do this search to facilitate future problems like this. I use this class in my app, be free to copy, edit, distribute etc.public class Preferences { private Context mContext; private SharedPreferences preferences; private SharedPreferences.Editor editor; private String FILE_NAME = "app.Preferences"; private int MODE = Context.MODE_PRIVATE; private String KEY_LOGGEDUSERID = "KEY_LOGGEDUSERID"; private String KEY_LOGGEDUSERNAME = "KEY_LOGGEDUSERNAME"; private String KEY_EMERGENCYID = "KEY_EMERGENCYID"; private String KEY_EMERGENCYNAME = "KEY_EMERGENCYNAME"; private String KEY_TIMEDELAY = "KEY_TIMEDELAY"; public Preferences(Context context) { mContext = context; preferences = mContext.getSharedPreferences(FILE_NAME, MODE); editor = preferences.edit(); } public void setLoggedUserId(String id) { editor.putString(KEY_LOGGEDUSERID, id); editor.commit(); } public String getLoggedUserId() { return preferences.getString(KEY_LOGGEDUSERID, ""); } public void setLoggedUserName(String name) { editor.putString(KEY_LOGGEDUSERNAME, name); editor.commit(); } public String getLoggedUserName() { return preferences.getString(KEY_LOGGEDUSERNAME, ""); } public void setEmergencyUserId(String id) { editor.putString(KEY_EMERGENCYID, id); editor.commit(); } public String getEmergencyUserId() { return preferences.getString(KEY_EMERGENCYID, ""); } public void setTimeDelay(String time) { editor.putString(KEY_TIMEDELAY, time); editor.commit(); } public String getTimeDelay() { return preferences.getString(KEY_TIMEDELAY, ""); } public void setEmergencyUserName(String name) { editor.putString(KEY_EMERGENCYNAME, name); editor.commit(); } public String getEmergencyUserName() { return preferences.getString(KEY_EMERGENCYNAME, ""); } } When I need to recover the value only use:Preferences preferences = new Preferences(this); String loggedUserId = preferences.getLoggedUserId();

"Yes", it is possible, not as directly as you may be thinking.1. Save preferences in something concreteUsing https://docs.oracle.com/javase/7/docs/api/java/io/ObjectOutputStream.html we can create a file with primitive data to be later read and transformed back into a Java object. The point here is to take all preferences and save on a Map (since they are keys and values) using the https://developer.android.com/reference/android/content/SharedPreferences.html#getAll() File prefsFile = new File(getExternalFilesDir(null), "prefs.bak"); if (!prefsFile.exists()) { if (!prefsFile.createNewFile()) // Falha ao criar arquivo } try { SharedPreferences prefs = getSharedPreferences("pref", MODE_PRIVATE); ObjectOutputStream output = new ObjectOutputStream(new FileOutputStream(prefsFile)); output.writeObject(prefs.getAll()); output.flush(); output.close(); } catch (IOException e) { // Falha ao escrever no arquivo } 2. Send prefs.bak to other deviceWell, there are several ways to do that. Once sent, know the path of the file.3. Read and apply prefs.bak on the other deviceSupposing both devices run your app:File prefsFile = new File("caminho/para/o/prefs.bak"); if (prefsFile.exists()) { try { SharedPreferences.Editor editor = getSharedPreferences("pref", MODE_PRIVATE).edit(); ObjectInputStream input = new ObjectInputStream(new FileInputStream(prefsFile)); // Ler o objeto como um mapa Map<String, ?> entries = (Map<String, ?>) input.readObject(); // Na falta de um método "putAll()" vamos dar um loop no mapa e pra cada entry, fazemos um apply() for (Map.Entry<String, ?> entry : entries.entrySet()) { Object o = entry.getValue(); String key = entry.getKey(); if (o instanceof Boolean) editor.putBoolean(key, (Boolean) o); else if (o instanceof Float) editor.putFloat(key, (Float) o); else if (o instanceof Integer) editor.putInt(key, (Integer) o); else if (o instanceof Long) editor.putLong(key, (Long) o); else if (o instanceof String) editor.putString(key, ((String) o)); } // Finalmente aplique os novos valores importados editor.apply(); } catch (ClassNotFoundException | IOException ex) { // Falha ao ler arquivo } } else { // Arquivo não encontrado }

"null" appears because when the array frases is built, the field nomedoHumano It is null. What the array saves in position 0 is the result of the expressionnomedoHumano + "se você traçar metas absurdamente altas e falhar, seu fracasso será muito melhor que o sucesso de todos" that is the concatenation of the field value nomedoHumano, at that time, with the expression between quotation marks. Any later change in the field value will not change the value saved in the array.

You can make a simple validation before popular EditText:if (myprefs.getInt("keybanca",0) != 0){ banca.setText(String.valueOf(val1)); } else { banca.setText(""); }

Retrofit.Builder builder = new Retrofit.Builder() .baseUrl("http://"+getSharedPreferences(PREFS_NAME, Context.MODE_PRIVATE).getString("PrefHost", "")+":8080/FazendaWebservice/webresources/fazenda/") .addConverterFactory(GsonConverterFactory.create());

How you are using firebase, I believe you don't have to use SharedPreferences in this case, because how you want to define a nickname unchanged If it does not exist, you will only need to apply logic directly using the firebase. SharedPreferences is useful in application configuration save cases (such as themes, colors, splash screens, etc). You can read a little more about SharedPrefences here: https://pt.stackoverflow.com/questions/51093/realizar-uma-a%C3%A7%C3%A3o-somente-quando-o-app-for-iniciado-pela-primeira-vez-ap%C3%B3s-a-ins/51099#51099 Basically, you will need to check if the user has a nickname, if he has, you do not show the nickname insertion screen, otherwise you show.Your node will probably look like this:{ "Users": [ { "userUUID/Key": { "name": "Corey", "apelido": "" } } ] } And the applied logic will be:DatabaseReference db = FirebaseDatabase.getInstance().getReference("Users"); db.child(db.push().getKey() /* UUID do usuario */).addValueEventListener(new ValueEventListener() { @Override public void onDataChange(DataSnapshot dataSnapshot) { if(dataSnapshot.child("apelido").exists()) { // o apelido já foi definido } else { // o apelido ainda não foi definido } } @Override public void onCancelled(DatabaseError error) { Log.e(TAG, error.toException()); } }); You will also be able to check if the nickname exists in other instances. What I mean is, if the user finishes the record, but does not set a nickname, you can check if the nickname was set as soon as the application is opened, with that same logic, making the user come back to set it. It can be when the app is opened or when the user enters your account.

Note the comments in the code, which explain what each line does.To save on SharedPreferences:// recupera (ou cria) uma instância editável do arquivo de preferencia do Android, // pelo seu nome/chave (no caso "pref") SharedPreferences.Editor editor = getSharedPreferences("pref", MODE_PRIVATE).edit(); // seta uma propriedade do tipo 'String', com a chave 'a' e com um valor string editor.putString("a", "stack overflow"); // seta uma propriedade do tipo 'int', com a chave 'b' e com um valor inteiro editor.putInt("b", 32); // seta uma propriedade do tipo 'boolean', com a chave 'c' e com um valor boolean editor.putBoolean("c", true); // aplica/salva as alterações nas preferencias editor.commit(); To recover the values of SharedPreferences:// recupera (ou cria) uma instância do arquivo de preferencia do Android, // pelo seu nome/chave (no caso "pref") SharedPreferences pref = getSharedPreferences("pref", MODE_PRIVATE); // recupera a propriedade com a chave 'a' e do tipo 'String', // passando um valor default como segundo parâmetro, // no caso de não encontrar um propriedade com essa chave para recuperar String a = pref.getString("a", null); // recupera a propriedade com a chave 'b' e do tipo 'int', // passando um valor default como segundo parâmetro, // no caso de não encontrar um propriedade com essa chave para recuperar int b = pref.getInt("b", 0); // recupera a propriedade com a chave 'c' e do tipo 'boolean', // passando um valor default como segundo parâmetro, no caso de não encontrar um // propriedade com essa chave para recuperar boolean c = pref.getBoolean("c", true); For more details see http://developer.android.com/reference/android/content/SharedPreferences.html and/or http://developer.android.com/training/basics/data-storage/shared-preferences.html .

Change your code for this:SharedPreferences sharedPreferences = getSharedPreferences("arquivoPreferencia", MODE_PRIVATE); List<String> frasesFavoritoArray = new Arraylist<>(); Map<String, ?> allEntries = sharedPreferences.getAll(); for (Map.Entry<String, ?> entry : allEntries.entrySet()) { frasesFavoritoArray.add(entry.getValue().toString()); }

The values saved in SharedPreferences function as a "Chave-Value" pair. To save multiple values, you have to use different keys. In your case, you are using the same "frases" key for the entire list. You can do something like this in your code:editor.putString("frase" + position, frasesR[position]); It will save the data in the keys "frase1", "frase2", etc. Then you have to adapt the code that reads these keys.Partially it is not a good practice to use SharedPreferences to save many data, especially if your list data is dynamic, as the stored data may not correspond to the time they were saved.

Come on.onSavedIntanceState : This saves additional screen information, such as variables that are not associated with View, for when recreating Activity, the data is populated!It saves (temporarily) the screen information when destroyed through the method https://developer.android.com/reference/android/app/Activity.html?hl=pt-br#onSaveInstanceState(android.os.Bundle) and makes available through the method https://developer.android.com/reference/android/app/Activity.html?hl=pt-br#onRestoreInstanceState(android.os.Bundle) .Transportation of this information is done through a https://developer.android.com/reference/android/os/Bundle.html?hl=pt-br . https://developer.android.com/training/basics/activity-lifecycle/recreating.html?hl=pt-br SharedPreferences: Usually used to save preferences!You can use https://developer.android.com/reference/android/content/SharedPreferences.html to save primitive data: booleans, floats, ints, longs and strings. This data will persist in user sessions (even if the application is deleted). https://developer.android.com/guide/topics/data/data-storage.html#pref Database: By default Android supports the http://www.sqlite.org/ , being used to store more robust and complex data. All created databases can be accessed by the name in any class of the application, but not out of it.The recommended method for creating a new SQLite database is to create a subclass of https://developer.android.com/reference/android/database/sqlite/SQLiteOpenHelper.html and modify the method https://developer.android.com/reference/android/database/sqlite/SQLiteOpenHelper.html#onCreate(android.database.sqlite.SQLiteDatabase) , where you can run an SQLite command to create tables in the database.You can run SQLite queries using methods of https://developer.android.com/reference/android/database/sqlite/SQLiteDatabase.html#query(boolean,%20java.lang.String,%20java.lang.String[],%20java.lang.String,%20java.lang.String[],%20java.lang.String,%20java.lang.String,%20java.lang.String,%20java.lang.String) of https://developer.android.com/reference/android/database/sqlite/SQLiteDatabase.html , which accept several query parameters, such as table to query, projection, selection, columns and grouping, among others. For complex queries, such as those requiring column aliases, use https://developer.android.com/reference/android/database/sqlite/SQLiteQueryBuilder.html , which provides several convenient methods for creating queries.Internal/External Storage: Through this it is possible to save/read files. Server: This is a service responsible for saving and providing the data. DURIDES: When should I use every guy?It depends on the situation and what your App proposes to do! Simple data, such as user preferences, can be stored in SharedPreferences. Registers, more complex information, such as Friends List, can be stored with SQLite. In these cases, this information remains on the user's Smartphone, in case of loss or theft, the information will be lost too! Then you can save this information on a Server (through a service) for when the user performs Login on a new device, this information is updated!Then it depends on what you will propose with your App!I can replace a SharedPreferences with an onSavedIntanceState or Vice versa?You can instead of using Bundle this method, save the information in SharedPreferences and redeem when recreate the screen! But this (personally) smells like Gambiarra! The two have different purposes! O onSavedIntanceState is used to save the data on screen and then display (when the user changes from Portrait to landscape, for example!), in how much the SharedPreferences saves the information even after finishing the app.Databases do not work the same way as a server or like internal storage?The database (in case SQlite) stores the information on the Smartphone. The server besides the database, has a service (an application) responsible for entering and providing the data!Why should I use these other two "the same function"?As I said, this will depend on whether you use it or not!If your App has data that doesn't often change, then searching every time the user enters the App would be a waste in the use of the internet. Instead of searching from the server every time, you can bring and store this information through the Internal Database (SQlite).Can I share these preferences with you?If I understand, you're talking about SharedPreferences, as said above, this is only available in your App, it's up to you to share or not!Does Web service fit into a server type?Yes! As said, Web Service is responsible for providing and storing information on the Server.

First step is to define android:key for the preference item. In this case you already have pref_key_info on the item. Soon after in your Fragment that extends PreferenceFragment should be created an instant using the method findPreference(). By the end, just use the method setOnPreferenceClickListener() to enter the event by clicking on the specific preference. See below how your code should be.Preference info = (Preference) findPreference("pref_key_info"); info.setOnPreferenceClickListener(new Preference.OnPreferenceClickListener() { @Override public boolean onPreferenceClick(Preference preference) { // aqui pode inserir a janela do dialogo return false; } }); More details about https://developer.android.com/guide/topics/ui/settings.html?hl=pt-br .

Okay, let's go then:first, you need to initialize the Service:import android.app.Service; import android.content.Intent; import android.os.IBinder; public class ServicoIniciadoNoBoot extends Service { @Override public IBinder onBind(Intent intent) { return null; } @Override public void onCreate() { super.onCreate(); // Algo para ser feito quando o serviço for criado } @Override public void onStart(Intent intent, int startId) { super.onStart(intent, startId); // algo que precisa ser feito quando o serviço for incializado } @Override public void onDestroy() { super.onDestroy(); // Algo que precisa ser feito quando o serviço for finalizado (destruido) } } Then you will need a BroadcastReceiver, in it is that there is the onReceive method that will be called at the conclusion of the boot event. In it, we will launch the Service we just created.import android.content.BroadcastReceiver; import android.content.Context; import android.content.Intent; public class BootCompletadoReceiver extends BroadcastReceiver{ @Override public void onReceive(Context context, Intent intent) { Intent serviceIntent = new Intent(context, ServicoIniciadoNoBoot.class); context.startService(serviceIntent); } } Then you need to modify the AndroidManifest file. xml so that the app responds to the service: 1) Add permission to capture the loading event in the boot of the device:<uses-permission android:name="android.permission.RECEIVE_BOOT_COMPLETED" /> 2) Register the Service:<service android:name=".ServicoIniciadoNoBoot" ></service> 3) register BroadcastReceiver to receive the event:<receiver android:name=".BootCompletadoReceiver" android:enabled="true" android:exported="false" > <intent-filter> <action android:name="android.intent.action.BOOT_COMPLETED" /> </intent-filter> </receiver> With these steps you create a service running in your app where every time it starts by the app it keeps running until the device completes the booot, that is, it is turned off. You owe what you've been doing there in code, so you just gave it to be generic, but I believe that onStart and onCreate of the Service you can manipulate your watch.I hope you help!

The best way to store your Token is when the user is successfully connected, i.e. when the Token has been successfully created. After that, just save the Token.For example, the user has connected to LoginActivity and was redirected to the HomeActivitySo...Home Activitypublic class HomeActivity extends Activity { SharedPreferences mPref = null; @Override public void onCreate (Bundle cicle) { super.onCreate(cicle); setContentView(R.layout.activity_home.xml); // Layout // SharedPreferences mPref = getSharedPreferences("tokenId", MODE_PRIVATE); } @Override public void onResume () { super.onResume(); mPref.edit().putInt("tokenId", "9102887").apply(); } } Login Activitypublic class LoginActivity extends Activity { SharedPreferences mPref = null; @Override public void onCreate (Bundle cicle) { super.onCreate(cicle); setContentView(R.layout.activity_home.xml); // Layout // SharedPreferences mPref = getSharedPreferences("tokenId", MODE_PRIVATE); } @Override public void onResume () { super.onResume(); // Se o token não for encontrado, o valor será 0 int token = mPref.getInt("tokenId", 0); // Envia um pedido de token pro servidor // recebe o token e compara com o token salvo // se forem semelhantes, entra na conta direto int tokenServer = webS.getToken(deviceId, user, pass); if(token == tokenServer) // sucesso } } You don't need necessarily save Token as Int. It was just an example, I believe that the recommended for your case is a String Really. And it doesn't change much, just putInt For putString. See documentation.Source: https://developer.android.com/reference/android/content/SharedPreferences.html

Normally, it is located in /data/data/com.pacote.do.seu.app/shared_prefs/nome_da_pref.xml.You need http://olhardigital.uol.com.br/noticia/root-para-android-saiba-o-que-e-e-como-fazer/40421 to access this file or use a function to read and show the direct content of your application, since only it and the superuser are allowed for this.

I think storing data in SharedPreferences is not a good idea. Instead, save progress in a local database, SQLite. Once you log back, just bring what has already been answered.

if (v.isSelected) { v.setBackgroundResource(R.drawable.volume_ligado) } else { v.setBackgroundResource(R.drawable.volume_mudo) } val prefs = getSharedPreferences("preferencias", Context.MODE_PRIVATE) val ed = prefs.edit() ed.putBoolean("chave", v.isSelected) ed.commit() abc_aprender_a.setOnClickListener({ v -> v.setBackgroundResource(R.drawable.check) val prefs = getSharedPreferences("preferencias", Context.MODE_PRIVATE) val boo = prefs.getBoolean("chave", true) if(boo){ playSoundInButton() } }

You can use JSON to save ArrayLists by using, for example, JSONArray ( https://developer.android.com/reference/org/json/JSONArray.html ), has an example in the international forum. https://stackoverflow.com/questions/17037340/converting-jsonarray-to-arraylist ArrayList<String> listdata = new ArrayList<String>(); JSONArray jArray = (JSONArray)jsonObject; if (jArray != null) { for (int i=0;i<jArray.length();i++){ listdata.add(jArray.get(i).toString()); } } But it is worth pointing out that from API 11 it is possible to use StringSets, as both are collections, depending on your need, this manipulation can be easier. https://developer.android.com/reference/android/content/SharedPreferences.Editor.html

I found the problem: In a system method, I was sending a string to save instead of the Setup Object, so I was playing those bars and deconfigurating my code.I was doing this:String config = "http://......"; SharedPreferences.setPreferences(ctx, "configuracao", config); Right jeito do:Configuracao configuracao = new Configuracao(); SharedPreferences.setPreferences(ctx, "configuracao", configuracao);

I don't know if I understand exactly what you want to do but maybe you can use a foreach to go through the "list" array and retrieve item by item.for (String item : lista) { // faça algo }