• Home
  • Line#
  • Scopes#
  • Navigate#
  • Raw
  • Download
1 // Copyright (C) 2019 Google LLC
2 //
3 // Licensed under the Apache License, Version 2.0 (the "License");
4 // you may not use this file except in compliance with the License.
5 // You may obtain a copy of the License at
6 //
7 //      http://www.apache.org/licenses/LICENSE-2.0
8 //
9 // Unless required by applicable law or agreed to in writing, software
10 // distributed under the License is distributed on an "AS IS" BASIS,
11 // WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
12 // See the License for the specific language governing permissions and
13 // limitations under the License.
14 
15 package com.google.android.icing;
16 
17 import android.util.Log;
18 import androidx.annotation.NonNull;
19 import androidx.annotation.Nullable;
20 import com.google.android.icing.proto.BatchGetResultProto;
21 import com.google.android.icing.proto.BatchPutResultProto;
22 import com.google.android.icing.proto.BlobProto;
23 import com.google.android.icing.proto.DebugInfoResultProto;
24 import com.google.android.icing.proto.DeleteByNamespaceResultProto;
25 import com.google.android.icing.proto.DeleteByQueryResultProto;
26 import com.google.android.icing.proto.DeleteBySchemaTypeResultProto;
27 import com.google.android.icing.proto.DeleteResultProto;
28 import com.google.android.icing.proto.GetAllNamespacesResultProto;
29 import com.google.android.icing.proto.GetOptimizeInfoResultProto;
30 import com.google.android.icing.proto.GetResultProto;
31 import com.google.android.icing.proto.GetSchemaResultProto;
32 import com.google.android.icing.proto.GetSchemaTypeResultProto;
33 import com.google.android.icing.proto.InitializeResultProto;
34 import com.google.android.icing.proto.OptimizeResultProto;
35 import com.google.android.icing.proto.PersistToDiskResultProto;
36 import com.google.android.icing.proto.PutResultProto;
37 import com.google.android.icing.proto.ReportUsageResultProto;
38 import com.google.android.icing.proto.ResetResultProto;
39 import com.google.android.icing.proto.SearchResultProto;
40 import com.google.android.icing.proto.SetSchemaResultProto;
41 import com.google.android.icing.proto.StatusProto;
42 import com.google.android.icing.proto.StorageInfoResultProto;
43 import com.google.android.icing.proto.SuggestionResponse;
44 import com.google.protobuf.ExtensionRegistryLite;
45 import com.google.protobuf.InvalidProtocolBufferException;
46 
47 /**
48  * Contains utility methods for IcingSearchEngine to convert byte arrays to the corresponding
49  * protos.
50  *
51  * <p>It is also being used by AppSearch dynamite 0p client APIs to convert byte arrays to the
52  * protos.
53  */
54 // TODO(b/347054358): Add unit tests for this class.
55 public final class IcingSearchEngineUtils {
56   private static final String TAG = "IcingSearchEngineUtils";
57   private static final ExtensionRegistryLite EXTENSION_REGISTRY_LITE =
58       ExtensionRegistryLite.getEmptyRegistry();
59 
IcingSearchEngineUtils()60   private IcingSearchEngineUtils() {}
61 
62   // TODO(b/240333360) Check to see if we can use one template function to replace those
63   @NonNull
byteArrayToInitializeResultProto( @ullable byte[] initializeResultBytes)64   public static InitializeResultProto byteArrayToInitializeResultProto(
65       @Nullable byte[] initializeResultBytes) {
66     if (initializeResultBytes == null) {
67       Log.e(TAG, "Received null InitializeResult from native.");
68       return InitializeResultProto.newBuilder()
69           .setStatus(StatusProto.newBuilder().setCode(StatusProto.Code.INTERNAL))
70           .build();
71     }
72 
73     try {
74       return InitializeResultProto.parseFrom(initializeResultBytes, EXTENSION_REGISTRY_LITE);
75     } catch (InvalidProtocolBufferException e) {
76       Log.e(TAG, "Error parsing InitializeResultProto.", e);
77       return InitializeResultProto.newBuilder()
78           .setStatus(StatusProto.newBuilder().setCode(StatusProto.Code.INTERNAL))
79           .build();
80     }
81   }
82 
83   @NonNull
byteArrayToSetSchemaResultProto( @ullable byte[] setSchemaResultBytes)84   public static SetSchemaResultProto byteArrayToSetSchemaResultProto(
85       @Nullable byte[] setSchemaResultBytes) {
86     if (setSchemaResultBytes == null) {
87       Log.e(TAG, "Received null SetSchemaResultProto from native.");
88       return SetSchemaResultProto.newBuilder()
89           .setStatus(StatusProto.newBuilder().setCode(StatusProto.Code.INTERNAL))
90           .build();
91     }
92 
93     try {
94       return SetSchemaResultProto.parseFrom(setSchemaResultBytes, EXTENSION_REGISTRY_LITE);
95     } catch (InvalidProtocolBufferException e) {
96       Log.e(TAG, "Error parsing SetSchemaResultProto.", e);
97       return SetSchemaResultProto.newBuilder()
98           .setStatus(StatusProto.newBuilder().setCode(StatusProto.Code.INTERNAL))
99           .build();
100     }
101   }
102 
103   @NonNull
byteArrayToGetSchemaResultProto( @ullable byte[] getSchemaResultBytes)104   public static GetSchemaResultProto byteArrayToGetSchemaResultProto(
105       @Nullable byte[] getSchemaResultBytes) {
106     if (getSchemaResultBytes == null) {
107       Log.e(TAG, "Received null GetSchemaResultProto from native.");
108       return GetSchemaResultProto.newBuilder()
109           .setStatus(StatusProto.newBuilder().setCode(StatusProto.Code.INTERNAL))
110           .build();
111     }
112 
113     try {
114       return GetSchemaResultProto.parseFrom(getSchemaResultBytes, EXTENSION_REGISTRY_LITE);
115     } catch (InvalidProtocolBufferException e) {
116       Log.e(TAG, "Error parsing GetSchemaResultProto.", e);
117       return GetSchemaResultProto.newBuilder()
118           .setStatus(StatusProto.newBuilder().setCode(StatusProto.Code.INTERNAL))
119           .build();
120     }
121   }
122 
123   @NonNull
byteArrayToGetSchemaTypeResultProto( @ullable byte[] getSchemaTypeResultBytes)124   public static GetSchemaTypeResultProto byteArrayToGetSchemaTypeResultProto(
125       @Nullable byte[] getSchemaTypeResultBytes) {
126     if (getSchemaTypeResultBytes == null) {
127       Log.e(TAG, "Received null GetSchemaTypeResultProto from native.");
128       return GetSchemaTypeResultProto.newBuilder()
129           .setStatus(StatusProto.newBuilder().setCode(StatusProto.Code.INTERNAL))
130           .build();
131     }
132 
133     try {
134       return GetSchemaTypeResultProto.parseFrom(getSchemaTypeResultBytes, EXTENSION_REGISTRY_LITE);
135     } catch (InvalidProtocolBufferException e) {
136       Log.e(TAG, "Error parsing GetSchemaTypeResultProto.", e);
137       return GetSchemaTypeResultProto.newBuilder()
138           .setStatus(StatusProto.newBuilder().setCode(StatusProto.Code.INTERNAL))
139           .build();
140     }
141   }
142 
143   @NonNull
byteArrayToPutResultProto(@ullable byte[] putResultBytes)144   public static PutResultProto byteArrayToPutResultProto(@Nullable byte[] putResultBytes) {
145     if (putResultBytes == null) {
146       Log.e(TAG, "Received null PutResultProto from native.");
147       return PutResultProto.newBuilder()
148           .setStatus(StatusProto.newBuilder().setCode(StatusProto.Code.INTERNAL))
149           .build();
150     }
151 
152     try {
153       return PutResultProto.parseFrom(putResultBytes, EXTENSION_REGISTRY_LITE);
154     } catch (InvalidProtocolBufferException e) {
155       Log.e(TAG, "Error parsing PutResultProto.", e);
156       return PutResultProto.newBuilder()
157           .setStatus(StatusProto.newBuilder().setCode(StatusProto.Code.INTERNAL))
158           .build();
159     }
160   }
161 
162   @NonNull
byteArrayToBatchPutResultProto( @ullable byte[] putResultsBytes)163   public static BatchPutResultProto byteArrayToBatchPutResultProto(
164       @Nullable byte[] putResultsBytes) {
165     if (putResultsBytes == null) {
166       Log.e(TAG, "Received null PutResultProtos from native.");
167       return BatchPutResultProto.newBuilder()
168           .setStatus(StatusProto.newBuilder().setCode(StatusProto.Code.INTERNAL))
169           .build();
170     }
171 
172     try {
173       return BatchPutResultProto.parseFrom(putResultsBytes, EXTENSION_REGISTRY_LITE);
174     } catch (InvalidProtocolBufferException e) {
175       Log.e(TAG, "Error parsing PutResultProtos.", e);
176       return BatchPutResultProto.newBuilder()
177           .setStatus(StatusProto.newBuilder().setCode(StatusProto.Code.INTERNAL))
178           .build();
179     }
180   }
181 
182   @NonNull
byteArrayToGetResultProto(@ullable byte[] getResultBytes)183   public static GetResultProto byteArrayToGetResultProto(@Nullable byte[] getResultBytes) {
184     if (getResultBytes == null) {
185       Log.e(TAG, "Received null GetResultProto from native.");
186       return GetResultProto.newBuilder()
187           .setStatus(StatusProto.newBuilder().setCode(StatusProto.Code.INTERNAL))
188           .build();
189     }
190 
191     try {
192       return GetResultProto.parseFrom(getResultBytes, EXTENSION_REGISTRY_LITE);
193     } catch (InvalidProtocolBufferException e) {
194       Log.e(TAG, "Error parsing GetResultProto.", e);
195       return GetResultProto.newBuilder()
196           .setStatus(StatusProto.newBuilder().setCode(StatusProto.Code.INTERNAL))
197           .build();
198     }
199   }
200 
201   @NonNull
byteArrayToBatchGetResultProto( @ullable byte[] batchGetResultBytes)202   public static BatchGetResultProto byteArrayToBatchGetResultProto(
203       @Nullable byte[] batchGetResultBytes) {
204     if (batchGetResultBytes == null) {
205       Log.e(TAG, "Received null BatchGetResultProto from native.");
206       return BatchGetResultProto.newBuilder()
207           .setStatus(StatusProto.newBuilder().setCode(StatusProto.Code.INTERNAL))
208           .build();
209     }
210 
211     try {
212       return BatchGetResultProto.parseFrom(batchGetResultBytes, EXTENSION_REGISTRY_LITE);
213     } catch (InvalidProtocolBufferException e) {
214       Log.e(TAG, "Error parsing BatchGetResultProto.", e);
215       return BatchGetResultProto.newBuilder()
216           .setStatus(StatusProto.newBuilder().setCode(StatusProto.Code.INTERNAL))
217           .build();
218     }
219   }
220 
221   @NonNull
byteArrayToReportUsageResultProto( @ullable byte[] reportUsageResultBytes)222   public static ReportUsageResultProto byteArrayToReportUsageResultProto(
223       @Nullable byte[] reportUsageResultBytes) {
224     if (reportUsageResultBytes == null) {
225       Log.e(TAG, "Received null ReportUsageResultProto from native.");
226       return ReportUsageResultProto.newBuilder()
227           .setStatus(StatusProto.newBuilder().setCode(StatusProto.Code.INTERNAL))
228           .build();
229     }
230 
231     try {
232       return ReportUsageResultProto.parseFrom(reportUsageResultBytes, EXTENSION_REGISTRY_LITE);
233     } catch (InvalidProtocolBufferException e) {
234       Log.e(TAG, "Error parsing ReportUsageResultProto.", e);
235       return ReportUsageResultProto.newBuilder()
236           .setStatus(StatusProto.newBuilder().setCode(StatusProto.Code.INTERNAL))
237           .build();
238     }
239   }
240 
241   @NonNull
byteArrayToGetAllNamespacesResultProto( @ullable byte[] getAllNamespacesResultBytes)242   public static GetAllNamespacesResultProto byteArrayToGetAllNamespacesResultProto(
243       @Nullable byte[] getAllNamespacesResultBytes) {
244     if (getAllNamespacesResultBytes == null) {
245       Log.e(TAG, "Received null GetAllNamespacesResultProto from native.");
246       return GetAllNamespacesResultProto.newBuilder()
247           .setStatus(StatusProto.newBuilder().setCode(StatusProto.Code.INTERNAL))
248           .build();
249     }
250 
251     try {
252       return GetAllNamespacesResultProto.parseFrom(
253           getAllNamespacesResultBytes, EXTENSION_REGISTRY_LITE);
254     } catch (InvalidProtocolBufferException e) {
255       Log.e(TAG, "Error parsing GetAllNamespacesResultProto.", e);
256       return GetAllNamespacesResultProto.newBuilder()
257           .setStatus(StatusProto.newBuilder().setCode(StatusProto.Code.INTERNAL))
258           .build();
259     }
260   }
261 
262   @NonNull
byteArrayToSearchResultProto(@ullable byte[] searchResultBytes)263   public static SearchResultProto byteArrayToSearchResultProto(@Nullable byte[] searchResultBytes) {
264     if (searchResultBytes == null) {
265       Log.e(TAG, "Received null SearchResultProto from native.");
266       return SearchResultProto.newBuilder()
267           .setStatus(StatusProto.newBuilder().setCode(StatusProto.Code.INTERNAL))
268           .build();
269     }
270 
271     try {
272       SearchResultProto.Builder searchResultProtoBuilder =
273           SearchResultProto.newBuilder().mergeFrom(searchResultBytes, EXTENSION_REGISTRY_LITE);
274       setNativeToJavaJniLatency(searchResultProtoBuilder);
275       return searchResultProtoBuilder.build();
276     } catch (InvalidProtocolBufferException e) {
277       Log.e(TAG, "Error parsing SearchResultProto.", e);
278       return SearchResultProto.newBuilder()
279           .setStatus(StatusProto.newBuilder().setCode(StatusProto.Code.INTERNAL))
280           .build();
281     }
282   }
283 
284   /**
285    * Converts a byte array to a {@link BlobProto}.
286    *
287    * @param blobBytes the byte array to convert
288    * @return the {@link BlobProto}
289    */
290   @NonNull
byteArrayToBlobProto(@ullable byte[] blobBytes)291   public static BlobProto byteArrayToBlobProto(@Nullable byte[] blobBytes) {
292     if (blobBytes == null) {
293       Log.e(TAG, "Received null BlobProto from native.");
294       return BlobProto.newBuilder()
295           .setStatus(StatusProto.newBuilder().setCode(StatusProto.Code.INTERNAL))
296           .build();
297     }
298 
299     try {
300       return BlobProto.newBuilder().mergeFrom(blobBytes, EXTENSION_REGISTRY_LITE).build();
301     } catch (InvalidProtocolBufferException e) {
302       Log.e(TAG, "Error parsing BlobProto.", e);
303       return BlobProto.newBuilder()
304           .setStatus(StatusProto.newBuilder().setCode(StatusProto.Code.INTERNAL))
305           .build();
306     }
307   }
308 
setNativeToJavaJniLatency( SearchResultProto.Builder searchResultProtoBuilder)309   private static void setNativeToJavaJniLatency(
310       SearchResultProto.Builder searchResultProtoBuilder) {
311     int nativeToJavaLatencyMs =
312         (int)
313             (System.currentTimeMillis()
314                 - searchResultProtoBuilder.getQueryStats().getNativeToJavaStartTimestampMs());
315     searchResultProtoBuilder.setQueryStats(
316         searchResultProtoBuilder.getQueryStats().toBuilder()
317             .setNativeToJavaJniLatencyMs(nativeToJavaLatencyMs));
318   }
319 
320   @NonNull
byteArrayToDeleteResultProto(@ullable byte[] deleteResultBytes)321   public static DeleteResultProto byteArrayToDeleteResultProto(@Nullable byte[] deleteResultBytes) {
322     if (deleteResultBytes == null) {
323       Log.e(TAG, "Received null DeleteResultProto from native.");
324       return DeleteResultProto.newBuilder()
325           .setStatus(StatusProto.newBuilder().setCode(StatusProto.Code.INTERNAL))
326           .build();
327     }
328 
329     try {
330       return DeleteResultProto.parseFrom(deleteResultBytes, EXTENSION_REGISTRY_LITE);
331     } catch (InvalidProtocolBufferException e) {
332       Log.e(TAG, "Error parsing DeleteResultProto.", e);
333       return DeleteResultProto.newBuilder()
334           .setStatus(StatusProto.newBuilder().setCode(StatusProto.Code.INTERNAL))
335           .build();
336     }
337   }
338 
339   @NonNull
byteArrayToSuggestionResponse( @ullable byte[] suggestionResponseBytes)340   public static SuggestionResponse byteArrayToSuggestionResponse(
341       @Nullable byte[] suggestionResponseBytes) {
342     if (suggestionResponseBytes == null) {
343       Log.e(TAG, "Received null suggestionResponseBytes from native.");
344       return SuggestionResponse.newBuilder()
345           .setStatus(StatusProto.newBuilder().setCode(StatusProto.Code.INTERNAL))
346           .build();
347     }
348 
349     try {
350       return SuggestionResponse.parseFrom(suggestionResponseBytes, EXTENSION_REGISTRY_LITE);
351     } catch (InvalidProtocolBufferException e) {
352       Log.e(TAG, "Error parsing suggestionResponseBytes.", e);
353       return SuggestionResponse.newBuilder()
354           .setStatus(StatusProto.newBuilder().setCode(StatusProto.Code.INTERNAL))
355           .build();
356     }
357   }
358 
359   @NonNull
byteArrayToDeleteByNamespaceResultProto( @ullable byte[] deleteByNamespaceResultBytes)360   public static DeleteByNamespaceResultProto byteArrayToDeleteByNamespaceResultProto(
361       @Nullable byte[] deleteByNamespaceResultBytes) {
362     if (deleteByNamespaceResultBytes == null) {
363       Log.e(TAG, "Received null DeleteByNamespaceResultProto from native.");
364       return DeleteByNamespaceResultProto.newBuilder()
365           .setStatus(StatusProto.newBuilder().setCode(StatusProto.Code.INTERNAL))
366           .build();
367     }
368 
369     try {
370       return DeleteByNamespaceResultProto.parseFrom(
371           deleteByNamespaceResultBytes, EXTENSION_REGISTRY_LITE);
372     } catch (InvalidProtocolBufferException e) {
373       Log.e(TAG, "Error parsing DeleteByNamespaceResultProto.", e);
374       return DeleteByNamespaceResultProto.newBuilder()
375           .setStatus(StatusProto.newBuilder().setCode(StatusProto.Code.INTERNAL))
376           .build();
377     }
378   }
379 
380   @NonNull
byteArrayToDeleteBySchemaTypeResultProto( @ullable byte[] deleteBySchemaTypeResultBytes)381   public static DeleteBySchemaTypeResultProto byteArrayToDeleteBySchemaTypeResultProto(
382       @Nullable byte[] deleteBySchemaTypeResultBytes) {
383     if (deleteBySchemaTypeResultBytes == null) {
384       Log.e(TAG, "Received null DeleteBySchemaTypeResultProto from native.");
385       return DeleteBySchemaTypeResultProto.newBuilder()
386           .setStatus(StatusProto.newBuilder().setCode(StatusProto.Code.INTERNAL))
387           .build();
388     }
389 
390     try {
391       return DeleteBySchemaTypeResultProto.parseFrom(
392           deleteBySchemaTypeResultBytes, EXTENSION_REGISTRY_LITE);
393     } catch (InvalidProtocolBufferException e) {
394       Log.e(TAG, "Error parsing DeleteBySchemaTypeResultProto.", e);
395       return DeleteBySchemaTypeResultProto.newBuilder()
396           .setStatus(StatusProto.newBuilder().setCode(StatusProto.Code.INTERNAL))
397           .build();
398     }
399   }
400 
401   @NonNull
byteArrayToDeleteByQueryResultProto( @ullable byte[] deleteResultBytes)402   public static DeleteByQueryResultProto byteArrayToDeleteByQueryResultProto(
403       @Nullable byte[] deleteResultBytes) {
404     if (deleteResultBytes == null) {
405       Log.e(TAG, "Received null DeleteResultProto from native.");
406       return DeleteByQueryResultProto.newBuilder()
407           .setStatus(StatusProto.newBuilder().setCode(StatusProto.Code.INTERNAL))
408           .build();
409     }
410 
411     try {
412       return DeleteByQueryResultProto.parseFrom(deleteResultBytes, EXTENSION_REGISTRY_LITE);
413     } catch (InvalidProtocolBufferException e) {
414       Log.e(TAG, "Error parsing DeleteResultProto.", e);
415       return DeleteByQueryResultProto.newBuilder()
416           .setStatus(StatusProto.newBuilder().setCode(StatusProto.Code.INTERNAL))
417           .build();
418     }
419   }
420 
421   @NonNull
byteArrayToPersistToDiskResultProto( @ullable byte[] persistToDiskResultBytes)422   public static PersistToDiskResultProto byteArrayToPersistToDiskResultProto(
423       @Nullable byte[] persistToDiskResultBytes) {
424     if (persistToDiskResultBytes == null) {
425       Log.e(TAG, "Received null PersistToDiskResultProto from native.");
426       return PersistToDiskResultProto.newBuilder()
427           .setStatus(StatusProto.newBuilder().setCode(StatusProto.Code.INTERNAL))
428           .build();
429     }
430 
431     try {
432       return PersistToDiskResultProto.parseFrom(persistToDiskResultBytes, EXTENSION_REGISTRY_LITE);
433     } catch (InvalidProtocolBufferException e) {
434       Log.e(TAG, "Error parsing PersistToDiskResultProto.", e);
435       return PersistToDiskResultProto.newBuilder()
436           .setStatus(StatusProto.newBuilder().setCode(StatusProto.Code.INTERNAL))
437           .build();
438     }
439   }
440 
441   @NonNull
byteArrayToOptimizeResultProto( @ullable byte[] optimizeResultBytes)442   public static OptimizeResultProto byteArrayToOptimizeResultProto(
443       @Nullable byte[] optimizeResultBytes) {
444     if (optimizeResultBytes == null) {
445       Log.e(TAG, "Received null OptimizeResultProto from native.");
446       return OptimizeResultProto.newBuilder()
447           .setStatus(StatusProto.newBuilder().setCode(StatusProto.Code.INTERNAL))
448           .build();
449     }
450 
451     try {
452       return OptimizeResultProto.parseFrom(optimizeResultBytes, EXTENSION_REGISTRY_LITE);
453     } catch (InvalidProtocolBufferException e) {
454       Log.e(TAG, "Error parsing OptimizeResultProto.", e);
455       return OptimizeResultProto.newBuilder()
456           .setStatus(StatusProto.newBuilder().setCode(StatusProto.Code.INTERNAL))
457           .build();
458     }
459   }
460 
461   @NonNull
byteArrayToGetOptimizeInfoResultProto( @ullable byte[] getOptimizeInfoResultBytes)462   public static GetOptimizeInfoResultProto byteArrayToGetOptimizeInfoResultProto(
463       @Nullable byte[] getOptimizeInfoResultBytes) {
464     if (getOptimizeInfoResultBytes == null) {
465       Log.e(TAG, "Received null GetOptimizeInfoResultProto from native.");
466       return GetOptimizeInfoResultProto.newBuilder()
467           .setStatus(StatusProto.newBuilder().setCode(StatusProto.Code.INTERNAL))
468           .build();
469     }
470 
471     try {
472       return GetOptimizeInfoResultProto.parseFrom(
473           getOptimizeInfoResultBytes, EXTENSION_REGISTRY_LITE);
474     } catch (InvalidProtocolBufferException e) {
475       Log.e(TAG, "Error parsing GetOptimizeInfoResultProto.", e);
476       return GetOptimizeInfoResultProto.newBuilder()
477           .setStatus(StatusProto.newBuilder().setCode(StatusProto.Code.INTERNAL))
478           .build();
479     }
480   }
481 
482   @NonNull
byteArrayToStorageInfoResultProto( @ullable byte[] storageInfoResultProtoBytes)483   public static StorageInfoResultProto byteArrayToStorageInfoResultProto(
484       @Nullable byte[] storageInfoResultProtoBytes) {
485     if (storageInfoResultProtoBytes == null) {
486       Log.e(TAG, "Received null StorageInfoResultProto from native.");
487       return StorageInfoResultProto.newBuilder()
488           .setStatus(StatusProto.newBuilder().setCode(StatusProto.Code.INTERNAL))
489           .build();
490     }
491 
492     try {
493       return StorageInfoResultProto.parseFrom(storageInfoResultProtoBytes, EXTENSION_REGISTRY_LITE);
494     } catch (InvalidProtocolBufferException e) {
495       Log.e(TAG, "Error parsing GetOptimizeInfoResultProto.", e);
496       return StorageInfoResultProto.newBuilder()
497           .setStatus(StatusProto.newBuilder().setCode(StatusProto.Code.INTERNAL))
498           .build();
499     }
500   }
501 
502   @NonNull
byteArrayToDebugInfoResultProto( @ullable byte[] debugInfoResultProtoBytes)503   public static DebugInfoResultProto byteArrayToDebugInfoResultProto(
504       @Nullable byte[] debugInfoResultProtoBytes) {
505     if (debugInfoResultProtoBytes == null) {
506       Log.e(TAG, "Received null DebugInfoResultProto from native.");
507       return DebugInfoResultProto.newBuilder()
508           .setStatus(StatusProto.newBuilder().setCode(StatusProto.Code.INTERNAL))
509           .build();
510     }
511 
512     try {
513       return DebugInfoResultProto.parseFrom(debugInfoResultProtoBytes, EXTENSION_REGISTRY_LITE);
514     } catch (InvalidProtocolBufferException e) {
515       Log.e(TAG, "Error parsing DebugInfoResultProto.", e);
516       return DebugInfoResultProto.newBuilder()
517           .setStatus(StatusProto.newBuilder().setCode(StatusProto.Code.INTERNAL))
518           .build();
519     }
520   }
521 
522   @NonNull
byteArrayToResetResultProto(@ullable byte[] resetResultBytes)523   public static ResetResultProto byteArrayToResetResultProto(@Nullable byte[] resetResultBytes) {
524     if (resetResultBytes == null) {
525       Log.e(TAG, "Received null ResetResultProto from native.");
526       return ResetResultProto.newBuilder()
527           .setStatus(StatusProto.newBuilder().setCode(StatusProto.Code.INTERNAL))
528           .build();
529     }
530 
531     try {
532       return ResetResultProto.parseFrom(resetResultBytes, EXTENSION_REGISTRY_LITE);
533     } catch (InvalidProtocolBufferException e) {
534       Log.e(TAG, "Error parsing ResetResultProto.", e);
535       return ResetResultProto.newBuilder()
536           .setStatus(StatusProto.newBuilder().setCode(StatusProto.Code.INTERNAL))
537           .build();
538     }
539   }
540 }
541