ViaLin/AndroidSource/SharedPreferences.java at main · resess/ViaLin · GitHub

History

478 lines (441 loc) · 19.5 KB

Raw

100

101

102

103

104

105

106

107

108

109

110

111

112

113

114

115

116

117

118

119

120

121

122

123

124

125

126

127

128

129

130

131

132

133

134

135

136

137

138

139

140

141

142

143

144

145

146

147

148

149

150

151

152

153

154

155

156

157

158

159

160

161

162

163

164

165

166

167

168

169

170

171

172

173

174

175

176

177

178

179

180

181

182

183

184

185

186

187

188

189

190

191

192

193

194

195

196

197

198

199

200

201

202

203

204

205

206

207

208

209

210

211

212

213

214

215

216

217

218

219

220

221

222

223

224

225

226

227

228

229

230

231

232

233

234

235

236

237

238

239

240

241

242

243

244

245

246

247

248

249

250

251

252

253

254

255

256

257

258

259

260

261

262

263

264

265

266

267

268

269

270

271

272

273

274

275

276

277

278

279

280

281

282

283

284

285

286

287

288

289

290

291

292

293

294

295

296

297

298

299

300

301

302

303

304

305

306

307

308

309

310

311

312

313

314

315

316

317

318

319

320

321

322

323

324

325

326

327

328

329

330

331

332

333

334

335

336

337

338

339

340

341

342

343

344

345

346

347

348

349

350

351

352

353

354

355

356

357

358

359

360

361

362

363

364

365

366

367

368

369

370

371

372

373

374

375

376

377

378

379

380

381

382

383

384

385

386

387

388

389

390

391

392

393

394

395

396

397

398

399

400

401

402

403

404

405

406

407

408

409

410

411

412

413

414

415

416

417

418

419

420

421

422

423

424

425

426

427

428

429

430

431

432

433

434

435

436

437

438

439

440

441

442

443

444

445

446

447

448

449

450

451

452

453

454

455

456

457

458

459

460

461

462

463

464

465

466

467

468

469

470

471

472

473

474

475

476

477

478

* 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

* http://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.

package android.content;

import android.annotation.Nullable;

import java.util.Map;

import java.util.Set;

/**

* Interface for accessing and modifying preference data returned by {@link

* Context#getSharedPreferences}. For any particular set of preferences,

* there is a single instance of this class that all clients share.

* Modifications to the preferences must go through an {@link Editor} object

* to ensure the preference values remain in a consistent state and control

* when they are committed to storage. Objects that are returned from the

* various <code>get</code> methods must be treated as immutable by the application.

* Note: This class does not support use across multiple processes.

* <div class="special reference">

* <h3>Developer Guides</h3>

* For more information about using SharedPreferences, read the

* <a href="{@docRoot}guide/topics/data/data-storage.html#pref">Data Storage</a>

* developer guide.</div>

* @see Context#getSharedPreferences

public interface SharedPreferences {

/**

* Interface definition for a callback to be invoked when a shared

* preference is changed.

public interface OnSharedPreferenceChangeListener {

/**

* Called when a shared preference is changed, added, or removed. This

* may be called even if a preference is set to its existing value.

* This callback will be run on your main thread.

* @param sharedPreferences The {@link SharedPreferences} that received

* the change.

* @param key The key of the preference that was changed, added, or

* removed.

void onSharedPreferenceChanged(SharedPreferences sharedPreferences, String key);

}

/**

* Interface used for modifying values in a {@link SharedPreferences}

* object. All changes you make in an editor are batched, and not copied

* back to the original {@link SharedPreferences} until you call {@link #commit}

* or {@link #apply}

public interface Editor {

public static void addSharedPrefsTaint(Editor editor, String key, PathTaint fileTaint, Object object) {

String taint = PathTaint.fileTaint(fileTaint, object);

if (!taint.isEmpty()) {

// StackTraceElement ste = Thread.currentThread().getStackTrace()[3];

// System.out.format("PathTaint: addSharedPrefsTaint: in method %s->%s, taint is %s %n", ste.getClassName(), ste.getMethodName(), taint);

editor.putString(key+"ZZZ_taint", taint);

}

public static void addSharedPrefsTaint(Editor editor, String key, PathTaint fileTaint) {

String taint = PathTaint.fileTaint(fileTaint);

if (!taint.isEmpty()) {

// StackTraceElement ste = Thread.currentThread().getStackTrace()[3];

// System.out.format("PathTaint: addSharedPrefsTaint: in method %s->%s, taint is %s %n", ste.getClassName(), ste.getMethodName(), taint);

editor.putString(key+"ZZZ_taint", taint);

}

public static void addSharedPrefsTaintTaintDroid(Editor editor, String key, int fileTaint, Object object) {

int taint = TaintDroid.fileTaint(fileTaint, object);

if (taint != 0) {

// StackTraceElement ste = Thread.currentThread().getStackTrace()[3];

// System.out.format("PathTaint: addSharedPrefsTaint: in method %s->%s, taint is %s %n", ste.getClassName(), ste.getMethodName(), taint);

editor.putInt(key+"ZZZ_taint", taint);

}

public static void addSharedPrefsTaintTaintDroid(Editor editor, String key, int taint) {

if (taint != 0) {

// StackTraceElement ste = Thread.currentThread().getStackTrace()[3];

// System.out.format("PathTaint: addSharedPrefsTaint: in method %s->%s, taint is %s %n", ste.getClassName(), ste.getMethodName(), taint);

editor.putInt(key+"ZZZ_taint", taint);

}

/**

* Set a String value in the preferences editor, to be written back once

* {@link #commit} or {@link #apply} are called.

* @param key The name of the preference to modify.

* @param value The new value for the preference. Passing {@code null}

* for this argument is equivalent to calling {@link #remove(String)} with

* this key.

* @return Returns a reference to the same Editor object, so you can

* chain put calls together.

Editor putString(String key, @Nullable String value);

/**

* Set a set of String values in the preferences editor, to be written

* back once {@link #commit} or {@link #apply} is called.

* @param key The name of the preference to modify.

* @param values The set of new values for the preference. Passing {@code null}

* for this argument is equivalent to calling {@link #remove(String)} with

* this key.

* @return Returns a reference to the same Editor object, so you can

* chain put calls together.

Editor putStringSet(String key, @Nullable Set<String> values);

/**

* Set an int value in the preferences editor, to be written back once

* {@link #commit} or {@link #apply} are called.

* @param key The name of the preference to modify.

* @param value The new value for the preference.

* @return Returns a reference to the same Editor object, so you can

* chain put calls together.

Editor putInt(String key, int value);

/**

* Set a long value in the preferences editor, to be written back once

* {@link #commit} or {@link #apply} are called.

* @param key The name of the preference to modify.

* @param value The new value for the preference.

* @return Returns a reference to the same Editor object, so you can

* chain put calls together.

Editor putLong(String key, long value);

/**

* Set a float value in the preferences editor, to be written back once

* {@link #commit} or {@link #apply} are called.

* @param key The name of the preference to modify.

* @param value The new value for the preference.

* @return Returns a reference to the same Editor object, so you can

* chain put calls together.

Editor putFloat(String key, float value);

/**

* Set a boolean value in the preferences editor, to be written back

* once {@link #commit} or {@link #apply} are called.

* @param key The name of the preference to modify.

* @param value The new value for the preference.

* @return Returns a reference to the same Editor object, so you can

* chain put calls together.

Editor putBoolean(String key, boolean value);

/**

* Mark in the editor that a preference value should be removed, which

* will be done in the actual preferences once {@link #commit} is

* called.

* Note that when committing back to the preferences, all removals

* are done first, regardless of whether you called remove before

* or after put methods on this editor.

* @param key The name of the preference to remove.

* @return Returns a reference to the same Editor object, so you can

* chain put calls together.

Editor remove(String key);

/**

* Mark in the editor to remove all values from the

* preferences. Once commit is called, the only remaining preferences

* will be any that you have defined in this editor.

* Note that when committing back to the preferences, the clear

* is done first, regardless of whether you called clear before

* or after put methods on this editor.

* @return Returns a reference to the same Editor object, so you can

* chain put calls together.

Editor clear();

/**

* Commit your preferences changes back from this Editor to the

* {@link SharedPreferences} object it is editing. This atomically

* performs the requested modifications, replacing whatever is currently

* in the SharedPreferences.

* Note that when two editors are modifying preferences at the same

* time, the last one to call commit wins.

* If you don't care about the return value and you're

* using this from your application's main thread, consider

* using {@link #apply} instead.

* @return Returns true if the new values were successfully written

* to persistent storage.

boolean commit();

/**

* Commit your preferences changes back from this Editor to the

* {@link SharedPreferences} object it is editing. This atomically

* performs the requested modifications, replacing whatever is currently

* in the SharedPreferences.

* Note that when two editors are modifying preferences at the same

* time, the last one to call apply wins.

* Unlike {@link #commit}, which writes its preferences out

* to persistent storage synchronously, {@link #apply}

* commits its changes to the in-memory

* {@link SharedPreferences} immediately but starts an

* asynchronous commit to disk and you won't be notified of

* any failures. If another editor on this

* {@link SharedPreferences} does a regular {@link #commit}

* while a {@link #apply} is still outstanding, the

* {@link #commit} will block until all async commits are

* completed as well as the commit itself.

* As {@link SharedPreferences} instances are singletons within

* a process, it's safe to replace any instance of {@link #commit} with

* {@link #apply} if you were already ignoring the return value.

* You don't need to worry about Android component

* lifecycles and their interaction with <code>apply()</code>

* writing to disk. The framework makes sure in-flight disk

* writes from <code>apply()</code> complete before switching

* states.

* The SharedPreferences.Editor interface

* isn't expected to be implemented directly. However, if you

* previously did implement it and are now getting errors

* about missing <code>apply()</code>, you can simply call

* {@link #commit} from <code>apply()</code>.

void apply();

}

public static PathTaint getSharedPrefsTaint(SharedPreferences prefs, String key) {

String taint = prefs.getString(key+"ZZZ_taint", null);

if (taint != null && !taint.isEmpty()) {

PathTaint contained = new PathTaint();

contained.site = taint;

contained.delta = -2;

contained.timeStamp = System.nanoTime();

// StackTraceElement ste = Thread.currentThread().getStackTrace()[3];

// System.out.format("PathTaint: getSharedPrefsTaint: in method %s->%s, taint is %s %n", ste.getClassName(), ste.getMethodName(), taint);

return contained;

} else {

// StackTraceElement ste = Thread.currentThread().getStackTrace()[3];

// System.out.format("PathTaint: getSharedPrefsTaint: in method %s->%s, taint is null %n", ste.getClassName(), ste.getMethodName());

return null;

}

public static PathTaint getSharedPrefsTaintAll(SharedPreferences prefs) {

StringBuilder taint = new StringBuilder();

for (Map.Entry<String, ?> entry : prefs.getAll().entrySet()) {

if (entry.getKey().endsWith("ZZZ_taint")) {

if (entry.getValue() instanceof String) {

taint.append((String) entry.getValue());

}

String taintStr = taint.toString();

if (taintStr != null && !taintStr.isEmpty()) {

PathTaint contained = new PathTaint();

contained.site = taintStr;

contained.delta = -2;

return contained;

// StackTraceElement ste = Thread.currentThread().getStackTrace()[3];

// System.out.format("PathTaint: getSharedPrefsTaint: in method %s->%s, taint is %s %n", ste.getClassName(), ste.getMethodName(), taintStr);

} else {

return null;

// StackTraceElement ste = Thread.currentThread().getStackTrace()[3];

// System.out.format("PathTaint: getSharedPrefsTaint: in method %s->%s, taint is null %n", ste.getClassName(), ste.getMethodName());

}

public static int getSharedPrefsTaintTaintDroid(SharedPreferences prefs, String key) {

int taint = prefs.getInt(key+"ZZZ_taint", 0);

return taint;

}

public static int getSharedPrefsTaintAllTaintDroid(SharedPreferences prefs) {

int taint = 0;

for (Map.Entry<String, ?> entry : prefs.getAll().entrySet()) {

if (entry.getKey().endsWith("ZZZ_taint")) {

if (entry.getValue() instanceof Integer) {

taint |= (Integer) entry.getValue();

}

return taint;

}

/**

* Retrieve all values from the preferences.

* Note that you must not modify the collection returned

* by this method, or alter any of its contents. The consistency of your

* stored data is not guaranteed if you do.

* @return Returns a map containing a list of pairs key/value representing

* the preferences.

* @throws NullPointerException

Map<String, ?> getAll();

/**

* Retrieve a String value from the preferences.

* @param key The name of the preference to retrieve.

* @param defValue Value to return if this preference does not exist.

* @return Returns the preference value if it exists, or defValue. Throws

* ClassCastException if there is a preference with this name that is not

* a String.

* @throws ClassCastException

@Nullable

String getString(String key, @Nullable String defValue);

/**

* Retrieve a set of String values from the preferences.

* Note that you must not modify the set instance returned

* by this call. The consistency of the stored data is not guaranteed

* if you do, nor is your ability to modify the instance at all.

* @param key The name of the preference to retrieve.

* @param defValues Values to return if this preference does not exist.

* @return Returns the preference values if they exist, or defValues.

* Throws ClassCastException if there is a preference with this name

* that is not a Set.

* @throws ClassCastException

@Nullable

Set<String> getStringSet(String key, @Nullable Set<String> defValues);

/**

* Retrieve an int value from the preferences.

* @param key The name of the preference to retrieve.

* @param defValue Value to return if this preference does not exist.

* @return Returns the preference value if it exists, or defValue. Throws

* ClassCastException if there is a preference with this name that is not

* an int.

* @throws ClassCastException

int getInt(String key, int defValue);

/**

* Retrieve a long value from the preferences.

* @param key The name of the preference to retrieve.

* @param defValue Value to return if this preference does not exist.

* @return Returns the preference value if it exists, or defValue. Throws

* ClassCastException if there is a preference with this name that is not

* a long.

* @throws ClassCastException

long getLong(String key, long defValue);

/**

* Retrieve a float value from the preferences.

* @param key The name of the preference to retrieve.

* @param defValue Value to return if this preference does not exist.

* @return Returns the preference value if it exists, or defValue. Throws

* ClassCastException if there is a preference with this name that is not

* a float.

* @throws ClassCastException

float getFloat(String key, float defValue);

/**

* Retrieve a boolean value from the preferences.

* @param key The name of the preference to retrieve.

* @param defValue Value to return if this preference does not exist.

* @return Returns the preference value if it exists, or defValue. Throws

* ClassCastException if there is a preference with this name that is not

* a boolean.

* @throws ClassCastException

boolean getBoolean(String key, boolean defValue);

/**

* Checks whether the preferences contains a preference.

* @param key The name of the preference to check.

* @return Returns true if the preference exists in the preferences,

* otherwise false.

boolean contains(String key);

/**

* Create a new Editor for these preferences, through which you can make

* modifications to the data in the preferences and atomically commit those

* changes back to the SharedPreferences object.

* Note that you must call {@link Editor#commit} to have any

* changes you perform in the Editor actually show up in the

* SharedPreferences.

* @return Returns a new instance of the {@link Editor} interface, allowing

* you to modify the values in this SharedPreferences object.

Editor edit();

/**

* Registers a callback to be invoked when a change happens to a preference.

* Caution: The preference manager does

* not currently store a strong reference to the listener. You must store a

* strong reference to the listener, or it will be susceptible to garbage

* collection. We recommend you keep a reference to the listener in the

* instance data of an object that will exist as long as you need the

* listener.

* @param listener The callback that will run.

* @see #unregisterOnSharedPreferenceChangeListener

void registerOnSharedPreferenceChangeListener(OnSharedPreferenceChangeListener listener);

/**

* Unregisters a previous callback.

* @param listener The callback that should be unregistered.

* @see #registerOnSharedPreferenceChangeListener

void unregisterOnSharedPreferenceChangeListener(OnSharedPreferenceChangeListener listener);

}

ViaLin/AndroidSource/SharedPreferences.java at main · resess/ViaLin · GitHub

Uh oh!

Expand file tree

Breadcrumbs

SharedPreferences.java

Latest commit

History

Breadcrumbs

SharedPreferences.java

File metadata and controls